mongoose 7.6.4 → 7.6.6

package/lib/aggregate.js

@@ -665,7 +665,7 @@ Aggregate.prototype.unionWith = function(options) {
  *     await Model.aggregate(pipeline).read('primaryPreferred');
  *
  * @param {String|ReadPreference} pref one of the listed preference options or their aliases
- * @param {Array} [tags] optional tags for this query. DEPRECATED
+ * @param {Array} [tags] optional tags for this query.
  * @return {Aggregate} this
  * @api public
  * @see mongodb https://www.mongodb.com/docs/manual/applications/replication/#read-preference

package/lib/cursor/ChangeStream.js

@@ -89,6 +89,9 @@ class ChangeStream extends EventEmitter {
         if (ev === 'error' && this.closed) {
           return;
         }
+        if (data != null && data.fullDocument != null && this.options && this.options.hydrate) {
+          data.fullDocument = this.options.model.hydrate(data.fullDocument);
+        }
         this.emit(ev, data);
       });
     });

package/lib/document.js

@@ -1181,6 +1181,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
         this.invalidate(path, new MongooseError.CastError('Object', val, path));
         return this;
       }
+      const wasModified = this.$isModified(path);
       const hasInitialVal = this.$__.savedState != null && this.$__.savedState.hasOwnProperty(path);
       if (this.$__.savedState != null && !this.$isNew && !this.$__.savedState.hasOwnProperty(path)) {
         const initialVal = this.$__getValue(path);
@@ -1203,9 +1204,11 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
       this.$__setValue(path, {});
       for (const key of keys) {
-        this.$set(path + '.' + key, val[key], constructing, options);
+        this.$set(path + '.' + key, val[key], constructing, { ...options, _skipMarkModified: true });
       }
-      if (priorVal != null && utils.deepEqual(hasInitialVal ? this.$__.savedState[path] : priorVal, val)) {
+      if (priorVal != null &&
+          (!wasModified || hasInitialVal) &&
+          utils.deepEqual(hasInitialVal ? this.$__.savedState[path] : priorVal, val)) {
         this.unmarkModified(path);
       } else {
         this.markModified(path);

package/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -32,9 +32,13 @@ const kHasArray = Symbol('assignRawDocsToIdStructure.hasArray');
  */
 
 function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, recursed) {
-  // honor user specified sort order
+  // honor user specified sort order, unless we're populating a single
+  // virtual underneath an array (e.g. populating `employees.mostRecentShift` where
+  // `mostRecentShift` is a virtual with `justOne`)
   const newOrder = [];
-  const sorting = options.sort && rawIds.length > 1;
+  const sorting = options.isVirtual && options.justOne && rawIds.length > 1
+    ? false :
+    options.sort && rawIds.length > 1;
   const nullIfNotFound = options.$nullIfNotFound;
   let doc;
   let sid;

package/lib/helpers/populate/assignVals.js

@@ -19,7 +19,8 @@ module.exports = function assignVals(o) {
   // `o.options` contains options explicitly listed in `populateOptions`, like
   // `match` and `limit`.
   const populateOptions = Object.assign({}, o.options, userOptions, {
-    justOne: o.justOne
+    justOne: o.justOne,
+    isVirtual: o.isVirtual
   });
   populateOptions.$nullIfNotFound = o.isVirtual;
   const populatedModel = o.populatedModel;
@@ -144,7 +145,7 @@ module.exports = function assignVals(o) {
 
     const parts = _path.split('.');
     let cur = docs[i];
-    const curPath = parts[0];
+    let curPath = parts[0];
     for (let j = 0; j < parts.length - 1; ++j) {
       // If we get to an array with a dotted path, like `arr.foo`, don't set
       // `foo` on the array.
@@ -167,6 +168,7 @@ module.exports = function assignVals(o) {
         cur[parts[j]] = {};
       }
       cur = cur[parts[j]];
+      curPath += parts[j + 1] ? `.${parts[j + 1]}` : '';
       // If the property in MongoDB is a primitive, we won't be able to populate
       // the nested path, so skip it. See gh-7545
       if (typeof cur !== 'object') {

package/lib/model.js

@@ -1516,7 +1516,12 @@ Model.diffIndexes = async function diffIndexes() {
 
   const model = this;
 
-  let dbIndexes = await model.listIndexes();
+  let dbIndexes = await model.listIndexes().catch(err => {
+    if (err.codeName == 'NamespaceNotFound') {
+      return undefined;
+    }
+    throw err;
+  });
   if (dbIndexes === undefined) {
     dbIndexes = [];
   }

package/lib/schema/SubdocumentPath.js

@@ -55,7 +55,6 @@ function SubdocumentPath(schema, path, options) {
   this.$isSingleNested = true;
   this.base = schema.base;
   SchemaType.call(this, path, options, 'Embedded');
-
   if (schema._applyDiscriminators != null && !options?._skipApplyDiscriminators) {
     for (const disc of schema._applyDiscriminators.keys()) {
       this.discriminator(disc, schema._applyDiscriminators.get(disc));

package/lib/schema/documentarray.js

@@ -89,7 +89,7 @@ function DocumentArrayPath(key, schema, options, schemaOptions) {
   this.$embeddedSchemaType.caster = this.Constructor;
   this.$embeddedSchemaType.schema = this.schema;
 
-  if (schema._applyDiscriminators != null) {
+  if (schema._applyDiscriminators != null && !options?._skipApplyDiscriminators) {
     for (const disc of schema._applyDiscriminators.keys()) {
       this.discriminator(disc, schema._applyDiscriminators.get(disc));
     }
@@ -528,7 +528,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
 
 DocumentArrayPath.prototype.clone = function() {
   const options = Object.assign({}, this.options);
-  const schematype = new this.constructor(this.path, this.schema, options, this.schemaOptions);
+  const schematype = new this.constructor(this.path, this.schema, { ...options, _skipApplyDiscriminators: true }, this.schemaOptions);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;

package/lib/schema.js

@@ -2577,7 +2577,7 @@ Schema.prototype._getSchema = function(path) {
               if (parts[p] === '$' || isArrayFilter(parts[p])) {
                 if (p + 1 === parts.length) {
                   // comments.$
-                  return foundschema;
+                  return foundschema.$embeddedSchemaType;
                 }
                 // comments.$.comments.$.title
                 ret = search(parts.slice(p + 1), foundschema.schema);

package/lib/statemachine.js

@@ -65,7 +65,11 @@ StateMachine.ctor = function() {
  */
 
 StateMachine.prototype._changeState = function _changeState(path, nextState) {
-  const prevBucket = this.states[this.paths[path]];
+  const prevState = this.paths[path];
+  if (prevState === nextState) {
+    return;
+  }
+  const prevBucket = this.states[prevState];
   if (prevBucket) delete prevBucket[path];
 
   this.paths[path] = nextState;

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

@@ -374,7 +374,15 @@ const methods = {
       if (val != null && utils.hasUserDefinedProperty(val, '$each')) {
         atomics.$push = val;
       } else {
-        atomics.$push.$each = atomics.$push.$each.concat(val);
+        if (val.length === 1) {
+          atomics.$push.$each.push(val[0]);
+        } else if (val.length < 10000) {
+          atomics.$push.$each.push(...val);
+        } else {
+          for (const v of val) {
+            atomics.$push.$each.push(v);
+          }
+        }
       }
     } else {
       atomics[op] = val;
@@ -403,8 +411,7 @@ const methods = {
   addToSet() {
     _checkManualPopulation(this, arguments);
 
-    let values = [].map.call(arguments, this._mapCast, this);
-    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
+    const values = [].map.call(arguments, this._mapCast, this);
     const added = [];
     let type = '';
     if (values[0] instanceof ArraySubdocument) {
@@ -415,7 +422,7 @@ const methods = {
       type = 'ObjectId';
     }
 
-    const rawValues = utils.isMongooseArray(values) ? values.__array : this;
+    const rawValues = utils.isMongooseArray(values) ? values.__array : values;
     const rawArray = utils.isMongooseArray(this) ? this.__array : this;
 
     rawValues.forEach(function(v) {
@@ -682,10 +689,7 @@ const methods = {
 
     _checkManualPopulation(this, values);
 
-    const parent = this[arrayParentSymbol];
     values = [].map.call(values, this._mapCast, this);
-    values = this[arraySchemaSymbol].applySetters(values, parent, undefined,
-      undefined, { skipDocumentArrayCast: true });
     let ret;
     const atomics = this[arrayAtomicsSymbol];
     this._markModified();
@@ -711,7 +715,7 @@ const methods = {
           'with different `$position`');
       }
       atomic = values;
-      ret = [].push.apply(arr, values);
+      ret = _basePush.apply(arr, values);
     }
 
     this._registerAtomic('$push', atomic);
@@ -917,7 +921,6 @@ const methods = {
       values = arguments;
     } else {
       values = [].map.call(arguments, this._cast, this);
-      values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
     }
 
     const arr = utils.isMongooseArray(this) ? this.__array : this;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.6.4",
+  "version": "7.6.6",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "^5.5.0",
     "kareem": "2.5.1",
-    "mongodb": "5.9.0",
+    "mongodb": "5.9.1",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",
@@ -93,9 +93,10 @@
     "docs:merge:6x": "git merge 6.x",
     "docs:test": "npm run docs:generate && npm run docs:generate:search",
     "docs:view": "node ./scripts/static.js",
-    "docs:prepare:publish:stable": "npm run docs:checkout:gh-pages && npm run docs:merge:stable && npm run docs:clean:stable && npm run docs:generate && npm run docs:generate:search",
+    "docs:prepare:publish:stable": "npm run docs:checkout:gh-pages && npm run docs:merge:stable && npm run docs:generate && npm run docs:generate:search",
     "docs:prepare:publish:5x": "npm run docs:checkout:5x && npm run docs:merge:5x && npm run docs:clean:stable && npm run docs:generate && npm run docs:copy:tmp && npm run docs:checkout:gh-pages && npm run docs:copy:tmp:5x",
     "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:prepare:publish:7x": "env DOCS_DEPLOY=true npm run docs:generate && npm run docs:checkout:gh-pages && rimraf ./docs/7.x && mv ./tmp ./docs/7.x",
     "docs:check-links": "blc http://127.0.0.1:8089 -ro",
     "lint": "eslint .",
     "lint-js": "eslint . --ext .js --ext .cjs",
@@ -105,8 +106,9 @@
     "prepublishOnly": "npm run build-browser",
     "release": "git pull && git push origin master --tags && npm publish",
     "release-5x": "git pull origin 5.x && git push origin 5.x && git push origin 5.x --tags && npm publish --tag 5x",
-    "release-6x": "git pull origin 6.x && git push origin 6.x && git push origin 6.x --tags && npm publish --tag legacy",
+    "release-6x": "git pull origin 6.x && git push origin 6.x && git push origin 6.x --tags && npm publish --tag 6x",
     "mongo": "node ./tools/repl.js",
+    "publish-7x": "npm publish --tag 7x",
     "test": "mocha --exit ./test/*.test.js",
     "test-deno": "deno run --allow-env --allow-read --allow-net --allow-run --allow-sys --allow-write ./test/deno.js",
     "test-rs": "START_REPLICA_SET=1 mocha --timeout 30000 --exit ./test/*.test.js",

package/types/index.d.ts

@@ -336,6 +336,7 @@ declare module 'mongoose' {
     post<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPostOptions & SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
     post<T = THydratedDocumentType>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPostOptions & { document: true, query: false }, fn: PostMiddlewareFunction<T, T>): this;
     // this = Query
+    post<T = Query<any, any>>(method: MongooseRawResultQueryMiddleware|MongooseRawResultQueryMiddleware[], fn: PostMiddlewareFunction<T, null | QueryResultType<T> | ModifyResult<QueryResultType<T>>>): this;
     post<T = Query<any, any>>(method: MongooseDefaultQueryMiddleware|MongooseDefaultQueryMiddleware[], fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
     post<T = Query<any, any>>(method: MongooseDistinctQueryMiddleware|MongooseDistinctQueryMiddleware[], options: SchemaPostOptions, fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
     post<T = Query<any, any>>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPostOptions & { document: false, query: true }, fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
@@ -633,7 +634,7 @@ declare module 'mongoose' {
    * { age: 30 }
    * ```
    */
-  export type UpdateQuery<T> = _UpdateQuery<T> & AnyObject;
+  export type UpdateQuery<T> = AnyKeys<T> & _UpdateQuery<T> & AnyObject;
 
   /**
    * A more strict form of UpdateQuery that enforces updating only

package/types/middlewares.d.ts

@@ -5,7 +5,9 @@ declare module 'mongoose' {
   type MongooseDistinctDocumentMiddleware = 'save' | 'init' | 'validate';
   type MongooseDocumentMiddleware = MongooseDistinctDocumentMiddleware | MongooseQueryAndDocumentMiddleware;
 
-  type MongooseDistinctQueryMiddleware = 'count' | 'estimatedDocumentCount' | 'countDocuments' | 'deleteMany' | 'distinct' | 'find' | 'findOne' | 'findOneAndDelete' | 'findOneAndRemove' | 'findOneAndReplace' | 'findOneAndUpdate' | 'replaceOne' | 'updateMany';
+  type MongooseRawResultQueryMiddleware = 'findOneAndUpdate' | 'findOneAndReplace' | 'findOneAndDelete';
+  type MongooseDistinctQueryMiddleware = 'count' | 'estimatedDocumentCount' | 'countDocuments' | 'deleteMany' | 'distinct' | 'find' | 'findOne' | 'findOneAndDelete' | 'findOneAndReplace' | 'findOneAndRemove' | 'findOneAndUpdate' | 'replaceOne' | 'updateMany';
+
   type MongooseDefaultQueryMiddleware = MongooseDistinctQueryMiddleware | 'updateOne' | 'deleteOne';
   type MongooseQueryMiddleware = MongooseDistinctQueryMiddleware | MongooseQueryAndDocumentMiddleware;
 

package/types/models.d.ts

@@ -461,8 +461,9 @@ declare module 'mongoose' {
 
     /** Casts and validates the given object against this model's schema, passing the given `context` to custom validators. */
     validate(): Promise<void>;
-    validate(optional: any): Promise<void>;
-    validate(optional: any, pathsToValidate: PathsToValidate): Promise<void>;
+    validate(obj: any): Promise<void>;
+    validate(obj: any, pathsOrOptions: PathsToValidate): Promise<void>;
+    validate(obj: any, pathsOrOptions: { pathsToSkip?: pathsToSkip }): Promise<void>;
 
     /** Watches the underlying collection for changes using [MongoDB change streams](https://www.mongodb.com/docs/manual/changeStreams/). */
     watch<ResultType extends mongodb.Document = any, ChangeType extends mongodb.ChangeStreamDocument = any>(pipeline?: Array<Record<string, unknown>>, options?: mongodb.ChangeStreamOptions & { hydrate?: boolean }): mongodb.ChangeStream<ResultType, ChangeType>;
@@ -546,6 +547,10 @@ declare module 'mongoose' {
       TRawDocType,
       'findOneAndDelete'
     >;
+    findByIdAndDelete<ResultDoc = THydratedDocumentType>(
+      id?: mongodb.ObjectId | any,
+      options?: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
     findByIdAndDelete<ResultDoc = THydratedDocumentType>(
       id?: mongodb.ObjectId | any,
       options?: QueryOptions<TRawDocType> | null
@@ -562,10 +567,6 @@ declare module 'mongoose' {
       TRawDocType,
       'findOneAndDelete'
     >;
-    findByIdAndRemove<ResultDoc = THydratedDocumentType>(
-      id?: mongodb.ObjectId | any,
-      options?: QueryOptions<TRawDocType> | null
-    ): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
 
     /** Creates a `findOneAndUpdate` query, filtering by the given `_id`. */
     findByIdAndUpdate<ResultDoc = THydratedDocumentType>(
@@ -615,6 +616,10 @@ declare module 'mongoose' {
       TRawDocType,
       'findOneAndDelete'
     >;
+    findOneAndDelete<ResultDoc = THydratedDocumentType>(
+      filter?: FilterQuery<TRawDocType>,
+      options?: QueryOptions<TRawDocType> & { includeResultMetadata: true }
+    ): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, TRawDocType, 'findOneAndDelete'>;
     findOneAndDelete<ResultDoc = THydratedDocumentType>(
       filter?: FilterQuery<TRawDocType>,
       options?: QueryOptions<TRawDocType> | null

package/types/query.d.ts

@@ -217,7 +217,7 @@ declare module 'mongoose' {
     allowDiskUse(value: boolean): this;
 
     /** Specifies arguments for an `$and` condition. */
-    and(array: FilterQuery<DocType>[]): this;
+    and(array: FilterQuery<RawDocType>[]): this;
 
     /** Specifies the batchSize option. */
     batchSize(val: number): this;
@@ -265,7 +265,7 @@ declare module 'mongoose' {
     comment(val: string): this;
 
     /** Specifies this query as a `count` query. */
-    count(criteria?: FilterQuery<DocType>): QueryWithHelpers<
+    count(criteria?: FilterQuery<RawDocType>): QueryWithHelpers<
       number,
       DocType,
       THelpers,
@@ -275,7 +275,7 @@ declare module 'mongoose' {
 
     /** Specifies this query as a `countDocuments` query. */
     countDocuments(
-      criteria?: FilterQuery<DocType>,
+      criteria?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType>
     ): QueryWithHelpers<number, DocType, THelpers, RawDocType, 'countDocuments'>;
 
@@ -291,10 +291,10 @@ declare module 'mongoose' {
      * collection, regardless of the value of `single`.
      */
     deleteMany(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType>
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'deleteMany'>;
-    deleteMany(filter: FilterQuery<DocType>): QueryWithHelpers<
+    deleteMany(filter: FilterQuery<RawDocType>): QueryWithHelpers<
       any,
       DocType,
       THelpers,
@@ -309,10 +309,10 @@ declare module 'mongoose' {
      * option.
      */
     deleteOne(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType>
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'deleteOne'>;
-    deleteOne(filter: FilterQuery<DocType>): QueryWithHelpers<
+    deleteOne(filter: FilterQuery<RawDocType>): QueryWithHelpers<
       any,
       DocType,
       THelpers,
@@ -324,7 +324,7 @@ declare module 'mongoose' {
     /** Creates a `distinct` query: returns the distinct values of the given `field` that match `filter`. */
     distinct<ReturnType = any>(
       field: string,
-      filter?: FilterQuery<DocType>
+      filter?: FilterQuery<RawDocType>
     ): QueryWithHelpers<Array<ReturnType>, DocType, THelpers, RawDocType, 'distinct'>;
 
     /** Specifies a `$elemMatch` query condition. When called with one argument, the most recent path passed to `where()` is used. */
@@ -364,71 +364,71 @@ declare module 'mongoose' {
 
     /** Creates a `find` query: gets a list of documents that match `filter`. */
     find(
-      filter: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null,
+      filter: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
     find(
-      filter: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null
+      filter: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null
     ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
     find(
-      filter: FilterQuery<DocType>
-    ): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
+      filter: FilterQuery<RawDocType>
+    ): QueryWithHelpers<Array<RawDocType>, DocType, THelpers, RawDocType, 'find'>;
     find(): QueryWithHelpers<Array<DocType>, DocType, THelpers, RawDocType, 'find'>;
 
     /** Declares the query a findOne operation. When executed, returns the first found document. */
     findOne(
-      filter?: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null,
+      filter?: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findOne(
-      filter?: FilterQuery<DocType>,
-      projection?: ProjectionType<DocType> | null
+      filter?: FilterQuery<RawDocType>,
+      projection?: ProjectionType<RawDocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findOne(
-      filter?: FilterQuery<DocType>
-    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
+      filter?: FilterQuery<RawDocType>
+    ): QueryWithHelpers<DocType | null, RawDocType, THelpers, RawDocType, 'findOne'>;
 
     /** Creates a `findOneAndDelete` query: atomically finds the given document, deletes it, and returns the document as it was before deletion. */
     findOneAndDelete(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndDelete'>;
 
     /** Creates a `findOneAndRemove` query: atomically finds the given document and deletes it. */
     findOneAndRemove(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndRemove'>;
 
     /** Creates a `findOneAndUpdate` query: atomically find the first document that matches `filter` and apply `update`. */
     findOneAndUpdate(
-      filter: FilterQuery<DocType>,
-      update: UpdateQuery<DocType>,
+      filter: FilterQuery<RawDocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { rawResult: true }
     ): QueryWithHelpers<ModifyResult<DocType>, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findOneAndUpdate(
-      filter: FilterQuery<DocType>,
-      update: UpdateQuery<DocType>,
+      filter: FilterQuery<RawDocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { upsert: true } & ReturnsNewDoc
     ): QueryWithHelpers<DocType, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findOneAndUpdate(
-      filter?: FilterQuery<DocType>,
-      update?: UpdateQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
+      update?: UpdateQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
 
     /** Declares the query a findById operation. When executed, returns the document with the given `_id`. */
     findById(
       id: mongodb.ObjectId | any,
-      projection?: ProjectionType<DocType> | null,
+      projection?: ProjectionType<RawDocType> | null,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findById(
       id: mongodb.ObjectId | any,
-      projection?: ProjectionType<DocType> | null
+      projection?: ProjectionType<RawDocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOne'>;
     findById(
       id: mongodb.ObjectId | any
@@ -443,22 +443,22 @@ declare module 'mongoose' {
     /** Creates a `findOneAndUpdate` query, filtering by the given `_id`. */
     findByIdAndUpdate(
       id: mongodb.ObjectId | any,
-      update: UpdateQuery<DocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { rawResult: true }
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate(
       id: mongodb.ObjectId | any,
-      update: UpdateQuery<DocType>,
+      update: UpdateQuery<RawDocType>,
       options: QueryOptions<DocType> & { upsert: true } & ReturnsNewDoc
     ): QueryWithHelpers<DocType, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate(
       id?: mongodb.ObjectId | any,
-      update?: UpdateQuery<DocType>,
+      update?: UpdateQuery<RawDocType>,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
     findByIdAndUpdate(
       id: mongodb.ObjectId | any,
-      update: UpdateQuery<DocType>
+      update: UpdateQuery<RawDocType>
     ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType, 'findOneAndUpdate'>;
 
     /** Specifies a `$geometry` condition */
@@ -472,7 +472,7 @@ declare module 'mongoose' {
     get(path: string): any;
 
     /** Returns the current query filter (also known as conditions) as a POJO. */
-    getFilter(): FilterQuery<DocType>;
+    getFilter(): FilterQuery<RawDocType>;
 
     /** Gets query options. */
     getOptions(): QueryOptions<DocType>;
@@ -481,7 +481,7 @@ declare module 'mongoose' {
     getPopulatedPaths(): Array<string>;
 
     /** Returns the current query filter. Equivalent to `getFilter()`. */
-    getQuery(): FilterQuery<DocType>;
+    getQuery(): FilterQuery<RawDocType>;
 
     /** Returns the current update operations as a JSON object. */
     getUpdate(): UpdateQuery<DocType> | UpdateWithAggregationPipeline | null;
@@ -551,7 +551,7 @@ declare module 'mongoose' {
     maxTimeMS(ms: number): this;
 
     /** Merges another Query or conditions object into this one. */
-    merge(source: Query<any, any> | FilterQuery<DocType>): this;
+    merge(source: Query<any, any> | FilterQuery<RawDocType>): this;
 
     /** Specifies a `$mod` condition, filters documents for documents whose `path` property is a number that is equal to `remainder` modulo `divisor`. */
     mod<K = string>(path: K, val: number): this;
@@ -579,10 +579,10 @@ declare module 'mongoose' {
     nin(val: Array<any>): this;
 
     /** Specifies arguments for an `$nor` condition. */
-    nor(array: Array<FilterQuery<DocType>>): this;
+    nor(array: Array<FilterQuery<RawDocType>>): this;
 
     /** Specifies arguments for an `$or` condition. */
-    or(array: Array<FilterQuery<DocType>>): this;
+    or(array: Array<FilterQuery<RawDocType>>): this;
 
     /**
      * Make this query throw an error if no documents match the given `filter`.
@@ -639,7 +639,7 @@ declare module 'mongoose' {
      * not accept any [atomic](https://www.mongodb.com/docs/manual/tutorial/model-data-for-atomic-operations/#pattern) operators (`$set`, etc.)
      */
     replaceOne(
-      filter?: FilterQuery<DocType>,
+      filter?: FilterQuery<RawDocType>,
       replacement?: DocType | AnyObject,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<any, DocType, THelpers, RawDocType, 'replaceOne'>;
@@ -698,9 +698,9 @@ declare module 'mongoose' {
     setOptions(options: QueryOptions<DocType>, overwrite?: boolean): this;
 
     /** Sets the query conditions to the provided JSON object. */
-    setQuery(val: FilterQuery<DocType> | null): void;
+    setQuery(val: FilterQuery<RawDocType> | null): void;
 
-    setUpdate(update: UpdateQuery<DocType> | UpdateWithAggregationPipeline): void;
+    setUpdate(update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline): void;
 
     /** Specifies an `$size` query condition. When called with one argument, the most recent path passed to `where()` is used. */
     size<K = string>(path: K, val: number): this;
@@ -738,8 +738,8 @@ declare module 'mongoose' {
      * the `multi` option.
      */
     updateMany(
-      filter?: FilterQuery<DocType>,
-      update?: UpdateQuery<DocType> | UpdateWithAggregationPipeline,
+      filter?: FilterQuery<RawDocType>,
+      update?: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateMany'>;
 
@@ -748,8 +748,8 @@ declare module 'mongoose' {
      * `update()`, except it does not support the `multi` or `overwrite` options.
      */
     updateOne(
-      filter?: FilterQuery<DocType>,
-      update?: UpdateQuery<DocType> | UpdateWithAggregationPipeline,
+      filter?: FilterQuery<RawDocType>,
+      update?: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline,
       options?: QueryOptions<DocType> | null
     ): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType, 'updateOne'>;