mongoose 6.7.2 → 6.7.4

package/lib/cast.js

@@ -264,7 +264,7 @@ module.exports = function cast(schema, obj, options, context) {
         }
 
         const strict = 'strict' in options ? options.strict : schema.options.strict;
-        const strictQuery = getStrictQuery(options, schema._userProvidedOptions, schema.options);
+        const strictQuery = getStrictQuery(options, schema._userProvidedOptions, schema.options, context);
         if (options.upsert && strict) {
           if (strict === 'throw') {
             throw new StrictModeError(path);
@@ -374,7 +374,7 @@ function _cast(val, numbertype, context) {
   }
 }
 
-function getStrictQuery(queryOptions, schemaUserProvidedOptions, schemaOptions) {
+function getStrictQuery(queryOptions, schemaUserProvidedOptions, schemaOptions, context) {
   if ('strictQuery' in queryOptions) {
     return queryOptions.strictQuery;
   }
@@ -387,5 +387,17 @@ function getStrictQuery(queryOptions, schemaUserProvidedOptions, schemaOptions)
   if ('strict' in schemaUserProvidedOptions) {
     return schemaUserProvidedOptions.strict;
   }
+  const mongooseOptions = context.mongooseCollection &&
+    context.mongooseCollection.conn &&
+    context.mongooseCollection.conn.base &&
+    context.mongooseCollection.conn.base.options;
+  if (mongooseOptions) {
+    if ('strictQuery' in mongooseOptions) {
+      return mongooseOptions.strictQuery;
+    }
+    if ('strict' in mongooseOptions) {
+      return mongooseOptions.strict;
+    }
+  }
   return schemaOptions.strictQuery;
 }

package/lib/document.js

@@ -220,6 +220,17 @@ function Document(obj, fields, skipId, options) {
  *     const user = await User.findOne({ name: 'John Smith' });
  *     user.$isNew; // false
  *
+ * Mongoose sets `$isNew` to `false` immediately after `save()` succeeds.
+ * That means Mongoose sets `$isNew` to false **before** `post('save')` hooks run.
+ * In `post('save')` hooks, `$isNew` will be `false` if `save()` succeeded.
+ *
+ * #### Example:
+ *
+ *     userSchema.post('save', function() {
+ *       this.$isNew; // false
+ *     });
+ *     await User.create({ name: 'John Smith' });
+ *
  * For subdocuments, `$isNew` is true if either the parent has `$isNew` set,
  * or if you create a new subdocument.
  *
@@ -1468,13 +1479,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       const doc = this.$isSubdocument ? this.ownerDocument() : this;
       savedState = doc.$__.savedState;
       savedStatePath = this.$isSubdocument ? this.$__.fullPath + '.' + path : path;
-      if (savedState != null) {
-        const firstDot = savedStatePath.indexOf('.');
-        const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
-        if (!savedState.hasOwnProperty(topLevelPath)) {
-          savedState[topLevelPath] = utils.clone(doc.$__getValue(topLevelPath));
-        }
-      }
+      doc.$__saveInitialState(savedStatePath);
     }
 
     this.$__set(pathToMark, path, options, constructing, parts, schema, val, priorVal);
@@ -1583,6 +1588,10 @@ Document.prototype.$__shouldModify = function(pathToMark, path, options, constru
   if (this.$isNew) {
     return true;
   }
+  // Is path already modified? If so, always modify. We may unmark modified later.
+  if (path in this.$__.activePaths.getStatePaths('modify')) {
+    return true;
+  }
 
   // Re: the note about gh-7196, `val` is the raw value without casting or
   // setters if the full path is under a single nested subdoc because we don't
@@ -1780,11 +1789,10 @@ Document.prototype.$inc = function $inc(path, val) {
 
   const currentValue = this.$__getValue(path) || 0;
 
-  this.$__setValue(path, currentValue + val);
-
   this.$__.primitiveAtomics = this.$__.primitiveAtomics || {};
   this.$__.primitiveAtomics[path] = { $inc: val };
   this.markModified(path);
+  this.$__setValue(path, currentValue + val);
 
   return this;
 };
@@ -1927,6 +1935,8 @@ Document.prototype.$__path = function(path) {
  */
 
 Document.prototype.markModified = function(path, scope) {
+  this.$__saveInitialState(path);
+
   this.$__.activePaths.modify(path);
   if (scope != null && !this.$isSubdocument) {
     this.$__.pathsToScopes = this.$__pathsToScopes || {};
@@ -1934,6 +1944,22 @@ Document.prototype.markModified = function(path, scope) {
   }
 };
 
+/*!
+ * ignore
+ */
+
+Document.prototype.$__saveInitialState = function $__saveInitialState(path) {
+  const savedState = this.$__.savedState;
+  const savedStatePath = path;
+  if (savedState != null) {
+    const firstDot = savedStatePath.indexOf('.');
+    const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
+    if (!savedState.hasOwnProperty(topLevelPath)) {
+      savedState[topLevelPath] = utils.clone(this.$__getValue(topLevelPath));
+    }
+  }
+};
+
 /**
  * Clears the modified state on the specified path.
  *
@@ -3379,6 +3405,7 @@ Document.prototype.$__dirty = function() {
       schema: _this.$__path(path)
     };
   });
+
   // gh-2558: if we had to set a default and the value is not undefined,
   // we have to save as well
   all = all.concat(this.$__.activePaths.map('default', function(path) {

package/lib/helpers/common.js

@@ -7,6 +7,8 @@
 const Binary = require('../driver').get().Binary;
 const isBsonType = require('./isBsonType');
 const isMongooseObject = require('./isMongooseObject');
+const MongooseError = require('../error');
+const util = require('util');
 
 exports.flatten = flatten;
 exports.modifiedPaths = modifiedPaths;
@@ -67,7 +69,25 @@ function flatten(update, path, options, schema) {
  * ignore
  */
 
-function modifiedPaths(update, path, result) {
+function modifiedPaths(update, path, result, recursion = null) {
+  if (update == null || typeof update !== 'object') {
+    return;
+  }
+
+  if (recursion == null) {
+    recursion = {
+      raw: { update, path },
+      trace: new WeakSet()
+    };
+  }
+
+  if (recursion.trace.has(update)) {
+    throw new MongooseError(`a circular reference in the update value, updateValue:
+${util.inspect(recursion.raw.update, { showHidden: false, depth: 1 })}
+updatePath: '${recursion.raw.path}'`);
+  }
+  recursion.trace.add(update);
+
   const keys = Object.keys(update || {});
   const numKeys = keys.length;
   result = result || {};
@@ -83,7 +103,7 @@ function modifiedPaths(update, path, result) {
       val = val.toObject({ transform: false, virtuals: false });
     }
     if (shouldFlatten(val)) {
-      modifiedPaths(val, path + key, result);
+      modifiedPaths(val, path + key, result, recursion);
     }
   }
 
@@ -96,11 +116,11 @@ function modifiedPaths(update, path, result) {
 
 function shouldFlatten(val) {
   return val &&
-    typeof val === 'object' &&
-    !(val instanceof Date) &&
-    !isBsonType(val, 'ObjectID') &&
-    (!Array.isArray(val) || val.length !== 0) &&
-    !(val instanceof Buffer) &&
-    !isBsonType(val, 'Decimal128') &&
-    !(val instanceof Binary);
+      typeof val === 'object' &&
+      !(val instanceof Date) &&
+      !isBsonType(val, 'ObjectID') &&
+      (!Array.isArray(val) || val.length !== 0) &&
+      !(val instanceof Buffer) &&
+      !isBsonType(val, 'Decimal128') &&
+      !(val instanceof Binary);
 }

package/lib/helpers/cursor/eachAsync.js

@@ -33,7 +33,7 @@ module.exports = function eachAsync(next, fn, options, callback) {
   const aggregatedErrors = [];
   const enqueue = asyncQueue();
 
-  let drained = false;
+  let aborted = false;
 
   return promiseOrCallback(callback, cb => {
     if (signal != null) {
@@ -42,7 +42,7 @@ module.exports = function eachAsync(next, fn, options, callback) {
       }
 
       signal.addEventListener('abort', () => {
-        drained = true;
+        aborted = true;
         return cb(null);
       }, { once: true });
     }
@@ -63,90 +63,104 @@ module.exports = function eachAsync(next, fn, options, callback) {
   function iterate(finalCallback) {
     let handleResultsInProgress = 0;
     let currentDocumentIndex = 0;
-    let documentsBatch = [];
 
     let error = null;
     for (let i = 0; i < parallel; ++i) {
-      enqueue(fetch);
+      enqueue(createFetch());
     }
 
-    function fetch(done) {
-      if (drained || error) {
-        return done();
-      }
+    function createFetch() {
+      let documentsBatch = [];
+      let drained = false;
+
+      return fetch;
 
-      next(function(err, doc) {
-        if (drained || error != null) {
+      function fetch(done) {
+        if (drained || aborted) {
+          return done();
+        } else if (error) {
           return done();
         }
-        if (err != null) {
-          if (continueOnError) {
-            aggregatedErrors.push(err);
-          } else {
-            error = err;
-            finalCallback(err);
+
+        next(function(err, doc) {
+          if (error != null) {
             return done();
           }
-        }
-        if (doc == null) {
-          drained = true;
-          if (handleResultsInProgress <= 0) {
-            const finalErr = continueOnError ?
-              createEachAsyncMultiError(aggregatedErrors) :
-              error;
-
-            finalCallback(finalErr);
-          } else if (batchSize && documentsBatch.length) {
-            handleNextResult(documentsBatch, currentDocumentIndex++, handleNextResultCallBack);
+          if (err != null) {
+            if (err.name === 'MongoCursorExhaustedError') {
+              // We may end up calling `next()` multiple times on an exhausted
+              // cursor, which leads to an error. In case cursor is exhausted,
+              // just treat it as if the cursor returned no document, which is
+              // how a cursor indicates it is exhausted.
+              doc = null;
+            } else if (continueOnError) {
+              aggregatedErrors.push(err);
+            } else {
+              error = err;
+              finalCallback(err);
+              return done();
+            }
+          }
+          if (doc == null) {
+            drained = true;
+            if (handleResultsInProgress <= 0) {
+              const finalErr = continueOnError ?
+                createEachAsyncMultiError(aggregatedErrors) :
+                error;
+
+              finalCallback(finalErr);
+            } else if (batchSize && documentsBatch.length) {
+              handleNextResult(documentsBatch, currentDocumentIndex++, handleNextResultCallBack);
+            }
+            return done();
           }
-          return done();
-        }
 
-        ++handleResultsInProgress;
+          ++handleResultsInProgress;
 
-        // Kick off the subsequent `next()` before handling the result, but
-        // make sure we know that we still have a result to handle re: #8422
-        immediate(() => done());
+          // Kick off the subsequent `next()` before handling the result, but
+          // make sure we know that we still have a result to handle re: #8422
+          immediate(() => done());
 
-        if (batchSize) {
-          documentsBatch.push(doc);
-        }
+          if (batchSize) {
+            documentsBatch.push(doc);
+          }
 
-        // If the current documents size is less than the provided patch size don't process the documents yet
-        if (batchSize && documentsBatch.length !== batchSize) {
-          immediate(() => enqueue(fetch));
-          return;
-        }
+          // If the current documents size is less than the provided batch size don't process the documents yet
+          if (batchSize && documentsBatch.length !== batchSize) {
+            immediate(() => enqueue(fetch));
+            return;
+          }
 
-        const docsToProcess = batchSize ? documentsBatch : doc;
+          const docsToProcess = batchSize ? documentsBatch : doc;
 
-        function handleNextResultCallBack(err) {
-          if (batchSize) {
-            handleResultsInProgress -= documentsBatch.length;
-            documentsBatch = [];
-          } else {
-            --handleResultsInProgress;
-          }
-          if (err != null) {
-            if (continueOnError) {
-              aggregatedErrors.push(err);
+          function handleNextResultCallBack(err) {
+            if (batchSize) {
+              handleResultsInProgress -= documentsBatch.length;
+              documentsBatch = [];
             } else {
-              error = err;
-              return finalCallback(err);
+              --handleResultsInProgress;
+            }
+            if (err != null) {
+              if (continueOnError) {
+                aggregatedErrors.push(err);
+              } else {
+                error = err;
+                return finalCallback(err);
+              }
+            }
+            if ((drained || aborted) && handleResultsInProgress <= 0) {
+              const finalErr = continueOnError ?
+                createEachAsyncMultiError(aggregatedErrors) :
+                error;
+              return finalCallback(finalErr);
             }
-          }
-          if (drained && handleResultsInProgress <= 0) {
-            const finalErr = continueOnError ?
-              createEachAsyncMultiError(aggregatedErrors) :
-              error;
-            return finalCallback(finalErr);
-          }
 
-          immediate(() => enqueue(fetch));
-        }
+            immediate(() => enqueue(fetch));
+          }
 
-        handleNextResult(docsToProcess, currentDocumentIndex++, handleNextResultCallBack);
-      });
+          handleNextResult(docsToProcess, currentDocumentIndex++, handleNextResultCallBack);
+        });
+      }
     }
   }
 

package/lib/helpers/timestamps/setupTimestamps.js

@@ -28,7 +28,7 @@ module.exports = function setupTimestamps(schema, timestamps) {
   schema.$timestamps = { createdAt: createdAt, updatedAt: updatedAt };
 
   if (createdAt && !schema.paths[createdAt]) {
-    const baseImmutableCreatedAt = schema.base.get('timestamps.createdAt.immutable');
+    const baseImmutableCreatedAt = schema.base != null ? schema.base.get('timestamps.createdAt.immutable') : null;
     const immutable = baseImmutableCreatedAt != null ? baseImmutableCreatedAt : true;
     schemaAdditions[createdAt] = { [schema.options.typeKey || 'type']: Date, immutable };
   }

package/lib/index.js

@@ -205,7 +205,6 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
  * - 'returnOriginal': If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`, `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to setting the `new` option to `true` for `findOneAndX()` calls by default. Read our [`findOneAndUpdate()` tutorial](/docs/tutorials/findoneandupdate.html) for more information.
  * - 'bufferCommands': enable/disable mongoose's buffering mechanism for all connections and models
  * - 'cloneSchemas': `false` by default. Set to `true` to `clone()` all schemas before compiling into a model.
- * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arugments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
  * - 'timestamps.createdAt.immutable': `true` by default. If `false`, it will change the `createdAt` field to be [`immutable: false`](https://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-immutable) which means you can update the `createdAt`
  * - 'maxTimeMS': If set, attaches [maxTimeMS](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/) to every query
  * - 'objectIdGetter': `true` by default. Mongoose adds a getter to MongoDB ObjectId's called `_id` that returns `this` for convenience with populate. Set this to false to remove the getter.

package/lib/model.js

@@ -4556,7 +4556,7 @@ Model.validate = function validate(obj, pathsToValidate, context, callback) {
  * - match: optional query conditions to match
  * - model: optional name of the model to use for population
  * - options: optional query options like sort, limit, etc
- * - justOne: optional boolean, if true Mongoose will always set `path` to an array. Inferred from schema by default.
+ * - justOne: optional boolean, if true Mongoose will always set `path` to a document, or `null` if no document was found. If false, Mongoose will always set `path` to an array, which will be empty if no documents are found. Inferred from schema by default.
  * - strictPopulate: optional boolean, set to `false` to allow populating paths that aren't in the schema.
  *
  * #### Example:

package/lib/query.js

@@ -4574,8 +4574,11 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * #### Example:
  *
  *     const res = await Person.updateOne({ name: 'Jean-Luc Picard' }, { ship: 'USS Enterprise' });
- *     res.n; // Number of documents matched
- *     res.nModified; // Number of documents modified
+ *     res.acknowledged; // Indicates if this write result was acknowledged. If not, then all other members of this result will be undefined.
+ *     res.matchedCount; // Number of documents that matched the filter
+ *     res.modifiedCount; // Number of documents that were modified
+ *     res.upsertedCount; // Number of documents that were upserted
+ *     res.upsertedId; // Identifier of the inserted document (if an upsert took place)
  *
  * This function triggers the following middleware.
  *
@@ -4638,8 +4641,11 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * #### Example:
  *
  *     const res = await Person.replaceOne({ _id: 24601 }, { name: 'Jean Valjean' });
- *     res.n; // Number of documents matched
- *     res.nModified; // Number of documents modified
+ *     res.acknowledged; // Indicates if this write result was acknowledged. If not, then all other members of this result will be undefined.
+ *     res.matchedCount; // Number of documents that matched the filter
+ *     res.modifiedCount; // Number of documents that were modified
+ *     res.upsertedCount; // Number of documents that were upserted
+ *     res.upsertedId; // Identifier of the inserted document (if an upsert took place)
  *
  * This function triggers the following middleware.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.7.2",
+  "version": "6.7.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/document.d.ts

@@ -190,9 +190,6 @@ declare module 'mongoose' {
     /** Returns the list of paths that have been modified. */
     modifiedPaths(options?: { includeChildren?: boolean }): Array<string>;
 
-    /** The name of the model */
-    modelName: string;
-
     /**
      * Overwrite all values in this document with the values of `obj`, except
      * for immutable properties. Behaves similarly to `set()`, except for it

package/types/index.d.ts

@@ -78,7 +78,13 @@ declare module 'mongoose' {
     schema?: TSchema,
     collection?: string,
     options?: CompileModelOptions
-  ): Model<InferSchemaType<TSchema>, ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>, ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>, {}, TSchema> & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
+  ): Model<
+  InferSchemaType<TSchema>,
+  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+  ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
+  ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
+  TSchema
+  > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
 
   export function model<T>(name: string, schema?: Schema<T, any, any> | Schema<T & Document, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
 

package/types/inferschematype.d.ts

@@ -161,29 +161,30 @@ type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends (
 type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}, TypeKey extends TypeKeyBaseType = DefaultTypeKey> =
   PathValueType extends Schema ? InferSchemaType<PathValueType> :
     PathValueType extends (infer Item)[] ? IfEquals<Item, never, any[], Item extends Schema ? Types.DocumentArray<ObtainDocumentPathType<Item, TypeKey>> : ObtainDocumentPathType<Item, TypeKey>[]> :
-      PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
-        IfEquals<PathValueType, Schema.Types.String> extends true ? PathEnumOrString<Options['enum']> :
-          IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']> :
-            PathValueType extends NumberSchemaDefinition ? Options['enum'] extends ReadonlyArray<any> ? Options['enum'][number] : number :
-              IfEquals<PathValueType, Schema.Types.Number> extends true ? number :
-                PathValueType extends DateSchemaDefinition ? Date :
-                  IfEquals<PathValueType, Schema.Types.Date> extends true ? Date :
-                    PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
-                      PathValueType extends BooleanSchemaDefinition ? boolean :
-                        IfEquals<PathValueType, Schema.Types.Boolean> extends true ? boolean :
-                          PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId :
-                            IfEquals<PathValueType, Types.ObjectId> extends true ? Types.ObjectId :
-                              IfEquals<PathValueType, Schema.Types.ObjectId> extends true ? Types.ObjectId :
-                                PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
-                                  IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
-                                    IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
-                                      PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
-                                        IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
-                                          PathValueType extends MapConstructor ? Map<string, ResolvePathType<Options['of']>> :
-                                            PathValueType extends ArrayConstructor ? any[] :
-                                              PathValueType extends typeof Schema.Types.Mixed ? any:
-                                                IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                                  IfEquals<PathValueType, {}> extends true ? any:
-                                                    PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                      PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, TypeKey> :
-                                                        unknown;
+      PathValueType extends ReadonlyArray<infer Item> ? IfEquals<Item, never, any[], Item extends Schema ? Types.DocumentArray<ObtainDocumentPathType<Item, TypeKey>> : ObtainDocumentPathType<Item, TypeKey>[]> :
+        PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']> :
+          IfEquals<PathValueType, Schema.Types.String> extends true ? PathEnumOrString<Options['enum']> :
+            IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']> :
+              PathValueType extends NumberSchemaDefinition ? Options['enum'] extends ReadonlyArray<any> ? Options['enum'][number] : number :
+                IfEquals<PathValueType, Schema.Types.Number> extends true ? number :
+                  PathValueType extends DateSchemaDefinition ? Date :
+                    IfEquals<PathValueType, Schema.Types.Date> extends true ? Date :
+                      PathValueType extends typeof Buffer | 'buffer' | 'Buffer' | typeof Schema.Types.Buffer ? Buffer :
+                        PathValueType extends BooleanSchemaDefinition ? boolean :
+                          IfEquals<PathValueType, Schema.Types.Boolean> extends true ? boolean :
+                            PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId :
+                              IfEquals<PathValueType, Types.ObjectId> extends true ? Types.ObjectId :
+                                IfEquals<PathValueType, Schema.Types.ObjectId> extends true ? Types.ObjectId :
+                                  PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
+                                    IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
+                                      IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
+                                        PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
+                                          IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
+                                            PathValueType extends MapConstructor ? Map<string, ResolvePathType<Options['of']>> :
+                                              PathValueType extends ArrayConstructor ? any[] :
+                                                PathValueType extends typeof Schema.Types.Mixed ? any:
+                                                  IfEquals<PathValueType, ObjectConstructor> extends true ? any:
+                                                    IfEquals<PathValueType, {}> extends true ? any:
+                                                      PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                                                        PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, TypeKey> :
+                                                          unknown;

package/types/pipelinestage.d.ts

@@ -213,7 +213,7 @@ declare module 'mongoose' {
 
     export interface ReplaceWith {
       /** [`$replaceWith` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/replaceWith/) */
-      $replaceWith: ObjectExpressionOperator | { [field: string]: Expression };
+      $replaceWith: ObjectExpressionOperator | { [field: string]: Expression } | `$${string}`;
     }
 
     export interface Sample {

package/types/populate.d.ts

@@ -26,8 +26,9 @@ declare module 'mongoose' {
      /** deep populate */
      populate?: string | PopulateOptions | (string | PopulateOptions)[];
      /**
-     * If true Mongoose will always set `path` to an array, if false Mongoose will
-     * always set `path` to a document. Inferred from schema by default.
+     * If true Mongoose will always set `path` to a document, or `null` if no document was found.
+     * If false Mongoose will always set `path` to an array, which will be empty if no documents are found.
+     * Inferred from schema by default.
      */
      justOne?: boolean;
      /** transform function to call on every populated doc */

package/types/query.d.ts

@@ -616,7 +616,7 @@ declare module 'mongoose' {
     then: Promise<ResultType>['then'];
 
     /** Converts this query to a customized, reusable query constructor with all arguments and options retained. */
-    toConstructor(): typeof Query<ResultType, DocType, THelpers, RawDocType>;
+    toConstructor<RetType = typeof Query>(): RetType;
 
     /** Declare and/or execute this query as an update() operation. */
     update(filter?: FilterQuery<DocType>, update?: UpdateQuery<DocType> | UpdateWithAggregationPipeline, options?: QueryOptions<DocType> | null, callback?: Callback<UpdateWriteOpResult>): QueryWithHelpers<UpdateWriteOpResult, DocType, THelpers, RawDocType>;