mongoose 5.13.2 → 5.13.6

package/index.d.ts

@@ -37,8 +37,7 @@ declare module 'mongoose' {
    * Mongoose constructor. The exports object of the `mongoose` module is an instance of this
    * class. Most apps will only use this one instance.
    */
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  export const Mongoose: new (options?: object | null) => typeof mongoose;
+  export const Mongoose: new (options?: MongooseOptions | null) => typeof mongoose;
 
   /**
    * The Mongoose Number [SchemaType](/docs/schematypes.html). Used for
@@ -93,7 +92,7 @@ declare module 'mongoose' {
   export function disconnect(cb: (err: CallbackError) => void): void;
 
   /** Gets mongoose options */
-  export function get(key: string): any;
+  export function get<K extends keyof MongooseOptions>(key: K): MongooseOptions[K];
 
   /**
    * Returns true if Mongoose can cast the given value to an ObjectId, or
@@ -120,7 +119,7 @@ declare module 'mongoose' {
    * [timestamps](/docs/guide.html#timestamps). You may stub out this function
    * using a tool like [Sinon](https://www.npmjs.com/package/sinon) for testing.
    */
-  export function now(): Date;
+  export function now(): NativeDate;
 
   /** Declares a global plugin executed on all Schemas. */
   export function plugin(fn: (schema: Schema, opts?: any) => void, opts?: any): typeof mongoose;
@@ -129,7 +128,7 @@ declare module 'mongoose' {
   export function pluralize(fn?: ((str: string) => string) | null): ((str: string) => string) | null;
 
   /** Sets mongoose options */
-  export function set(key: string, value: any): void;
+  export function set<K extends keyof MongooseOptions>(key: K, value: MongooseOptions[K]): typeof mongoose;
 
   /**
    * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
@@ -146,6 +145,135 @@ declare module 'mongoose' {
 
   type Mongoose = typeof mongoose;
 
+  interface MongooseOptions {
+    /** true by default. Set to false to skip applying global plugins to child schemas */
+    applyPluginsToChildSchemas?: boolean;
+
+    /**
+     * false by default. Set to true to apply global plugins to discriminator schemas.
+     * This typically isn't necessary because plugins are applied to the base schema and
+     * discriminators copy all middleware, methods, statics, and properties from the base schema.
+     */
+    applyPluginsToDiscriminators?: boolean;
+
+    /**
+     * Set to `true` to make Mongoose call` Model.createCollection()` automatically when you
+     * create a model with `mongoose.model()` or `conn.model()`. This is useful for testing
+     * transactions, change streams, and other features that require the collection to exist.
+     */
+    autoCreate?: boolean;
+
+    /**
+     * true by default. Set to false to disable automatic index creation
+     * for all models associated with this Mongoose instance.
+     */
+    autoIndex?: boolean;
+
+    /** enable/disable mongoose's buffering mechanism for all connections and models */
+    bufferCommands?: boolean;
+
+    bufferTimeoutMS?: number;
+
+    /** false by default. Set to `true` to `clone()` all schemas before compiling into a model. */
+    cloneSchemas?: boolean;
+
+    /**
+     * 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 arguments 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(', ')})`.
+     */
+    debug?:
+      | boolean
+      | { color?: boolean; shell?: boolean }
+      | stream.Writable
+      | ((collectionName: string, methodName: string, ...methodArgs: any[]) => void);
+
+    /** If set, attaches [maxTimeMS](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/) to every query */
+    maxTimeMS?: number;
+
+    /**
+     * 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.
+     */
+    objectIdGetter?: boolean;
+
+    /**
+     * Set to `true` to default to overwriting models with the same name when calling
+     * `mongoose.model()`, as opposed to throwing an `OverwriteModelError`.
+     */
+    overwriteModels?: boolean;
+
+    /**
+     * 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](https://mongoosejs.com/docs/tutorials/findoneandupdate.html)
+     * for more information.
+     */
+    returnOriginal?: boolean;
+
+    /**
+     * false by default. Set to true to enable [update validators](
+     * https://mongoosejs.com/docs/validation.html#update-validators
+     * ) for all validators by default.
+     */
+    runValidators?: boolean;
+
+    sanitizeProjection?: boolean;
+
+    /**
+     * true by default. Set to false to opt out of Mongoose adding all fields that you `populate()`
+     * to your `select()`. The schema-level option `selectPopulatedPaths` overwrites this one.
+     */
+    selectPopulatedPaths?: boolean;
+
+    setDefaultsOnInsert?: boolean;
+
+    /** true by default, may be `false`, `true`, or `'throw'`. Sets the default strict mode for schemas. */
+    strict?: boolean | 'throw';
+
+    /**
+     * false by default, may be `false`, `true`, or `'throw'`. Sets the default
+     * [strictQuery](https://mongoosejs.com/docs/guide.html#strictQuery) mode for schemas.
+     */
+    strictQuery?: boolean | 'throw';
+
+    /**
+     * `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to
+     * `toJSON()`, for determining how Mongoose documents get serialized by `JSON.stringify()`
+     */
+    toJSON?: ToObjectOptions;
+
+    /** `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to `toObject()` */
+    toObject?: ToObjectOptions;
+
+    /** true by default, may be `false` or `true`. Sets the default typePojoToMixed for schemas. */
+    typePojoToMixed?: boolean;
+
+    /**
+     * false by default. Set to `true` to make Mongoose's default index build use `createIndex()`
+     * instead of `ensureIndex()` to avoid deprecation warnings from the MongoDB driver.
+     */
+    useCreateIndex?: boolean;
+
+    /**
+     * true by default. Set to `false` to make `findOneAndUpdate()` and `findOneAndRemove()`
+     * use native `findOneAndUpdate()` rather than `findAndModify()`.
+     */
+    useFindAndModify?: boolean;
+
+    /** false by default. Set to `true` to make all connections set the `useNewUrlParser` option by default */
+    useNewUrlParser?: boolean;
+
+    usePushEach?: boolean;
+
+    /** false by default. Set to `true` to make all connections set the `useUnifiedTopology` option by default */
+    useUnifiedTopology?: boolean;
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-empty-interface
   interface ClientSession extends mongodb.ClientSession { }
 
@@ -166,6 +294,10 @@ declare module 'mongoose' {
     autoCreate?: boolean;
     /** False by default. If `true`, this connection will use `createIndex()` instead of `ensureIndex()` for automatic index builds via `Model.init()`. */
     useCreateIndex?: boolean;
+    /** false by default. Set to `true` to make all connections set the `useNewUrlParser` option by default */
+    useNewUrlParser?: boolean;
+    /** false by default. Set to `true` to make all connections set the `useUnifiedTopology` option by default */
+    useUnifiedTopology?: boolean;
   }
 
   class Connection extends events.EventEmitter {
@@ -618,20 +750,26 @@ declare module 'mongoose' {
 
   interface AcceptsDiscriminator {
     /** Adds a discriminator type. */
-    discriminator<D extends Document>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<D>;
-    discriminator<T extends Document, U extends Model<T>>(name: string | number, schema: Schema<T, U>, value?: string | number | ObjectId): U;
+    discriminator<D>(name: string | number, schema: Schema<D>, value?: string | number | ObjectId): Model<D>;
+    discriminator<T, U extends Model<T>>(name: string | number, schema: Schema<T, U>, value?: string | number | ObjectId): U;
   }
 
+  type AnyKeys<T> = { [P in keyof T]?: T[P] | any };
   interface AnyObject { [k: string]: any }
   type EnforceDocument<T, TMethods> = T extends Document ? T : T & Document<any, any, T> & TMethods;
 
+  interface IndexesDiff {
+    /** Indexes that would be created in mongodb. */
+    toCreate: Array<any>
+    /** Indexes that would be dropped in mongodb. */
+    toDrop: Array<any>
+  }
+
   export const Model: Model<any>;
-  // eslint-disable-next-line no-undef
   interface Model<T, TQueryHelpers = {}, TMethods = {}> extends NodeJS.EventEmitter, AcceptsDiscriminator {
-    new(doc?: T | any): EnforceDocument<T, TMethods>;
+    new(doc?: AnyKeys<T> & AnyObject): EnforceDocument<T, TMethods>;
 
     aggregate<R = any>(pipeline?: any[]): Aggregate<Array<R>>;
-    // eslint-disable-next-line @typescript-eslint/ban-types
     aggregate<R = any>(pipeline: any[], cb: Function): Promise<Array<R>>;
 
     /** Base Mongoose instance the model uses. */
@@ -722,7 +860,6 @@ declare module 'mongoose' {
      * Event emitter that reports any errors that occurred. Useful for global error
      * handling.
      */
-    // eslint-disable-next-line no-undef
     events: NodeJS.EventEmitter;
 
     /**
@@ -786,6 +923,14 @@ declare module 'mongoose' {
     syncIndexes(options?: Record<string, unknown>): Promise<Array<string>>;
     syncIndexes(options: Record<string, unknown> | null, callback: (err: CallbackError, dropped: Array<string>) => void): void;
 
+    /**
+     * Does a dry-run of Model.syncIndexes(), meaning that
+     * the result of this function would be the result of
+     * Model.syncIndexes().
+     */
+    diffIndexes(options?: Record<string, unknown>): Promise<IndexesDiff>
+    diffIndexes(options: Record<string, unknown> | null, callback: (err: CallbackError, diff: IndexesDiff) => void): void
+
     /**
      * Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
      * for benefits like causal consistency, [retryable writes](https://docs.mongodb.com/manual/core/retryable-writes/),
@@ -802,7 +947,6 @@ declare module 'mongoose' {
     watch(pipeline?: Array<Record<string, unknown>>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream;
 
     /** Adds a `$where` clause to this query */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     $where(argument: string | Function): QueryWithHelpers<Array<EnforceDocument<T, TMethods>>, EnforceDocument<T, TMethods>, TQueryHelpers, T>;
 
     /** Registered discriminators for this model. */
@@ -998,7 +1142,6 @@ declare module 'mongoose' {
   }
 
   interface MapReduceOptions<T, Key, Val> {
-    // eslint-disable-next-line @typescript-eslint/ban-types
     map: Function | string;
     reduce: (key: Key, vals: T[]) => Val;
     /** query filter object. */
@@ -1134,7 +1277,7 @@ declare module 'mongoose' {
     eachPath(fn: (path: string, type: SchemaType) => void): this;
 
     /** Defines an index (most likely compound) for this schema. */
-    index(fields: any, options?: any): this;
+    index(fields: mongodb.IndexSpecification, options?: IndexOptions): this;
 
     /**
      * Returns a list of indexes that this schema declares, via `schema.index()`
@@ -1143,7 +1286,7 @@ declare module 'mongoose' {
     indexes(): Array<any>;
 
     /** Gets a schema option. */
-    get(path: string): any;
+    get<K extends keyof SchemaOptions>(key: K): SchemaOptions[K];
 
     /**
      * Loads an ES6 class into a schema. Maps [setters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set) + [getters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get), [static methods](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/static),
@@ -1152,11 +1295,9 @@ declare module 'mongoose' {
      * [statics](http://mongoosejs.com/docs/guide.html#statics), and
      * [methods](http://mongoosejs.com/docs/guide.html#methods).
      */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     loadClass(model: Function, onlyVirtuals?: boolean): this;
 
     /** Adds an instance method to documents constructed from Models compiled from this schema. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     method(name: string, fn: (this: EnforceDocument<DocType, TInstanceMethods>, ...args: any[]) => any, opts?: any): this;
     method(obj: { [name: string]: (this: EnforceDocument<DocType, TInstanceMethods>, ...args: any[]) => any }): this;
 
@@ -1167,7 +1308,7 @@ declare module 'mongoose' {
     obj: any;
 
     /** Gets/sets schema paths. */
-    path(path: string): SchemaType;
+    path<ResultType extends SchemaType = SchemaType>(path: string): ResultType;
     path(path: string, constructor: any): this;
 
     /** Lists all paths and their type in the schema. */
@@ -1224,12 +1365,10 @@ declare module 'mongoose' {
     requiredPaths(invalidate?: boolean): string[];
 
     /** Sets a schema option. */
-    set(path: string, value: any, _tags?: any): this;
+    set<K extends keyof SchemaOptions>(key: K, value: SchemaOptions[K], _tags?: any): this;
 
     /** Adds static "class" methods to Models compiled from this schema. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     static(name: string, fn: (this: M, ...args: any[]) => any): this;
-    // eslint-disable-next-line @typescript-eslint/ban-types
     static(obj: { [name: string]: (this: M, ...args: any[]) => any }): this;
 
     /** Object of currently defined statics on this schema. */
@@ -1432,7 +1571,7 @@ declare module 'mongoose' {
   interface SchemaTimestampsConfig {
     createdAt?: boolean | string;
     updatedAt?: boolean | string;
-    currentTime?: () => (Date | number);
+    currentTime?: () => (NativeDate | number);
   }
 
   type Unpacked<T> = T extends (infer U)[] ? U : T;
@@ -1452,7 +1591,6 @@ declare module 'mongoose' {
     alias?: string;
 
     /** Function or object describing how to validate this schematype. See [validation docs](https://mongoosejs.com/docs/validation.html). */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     validate?: RegExp | [RegExp, string] | Function | [Function, string] | ValidateOpts<T> | ValidateOpts<T>[];
 
     /** Allows overriding casting logic for this individual path. If a string, the given string overwrites Mongoose's default cast error message. */
@@ -1533,13 +1671,13 @@ declare module 'mongoose' {
     subtype?: number
 
     /** The minimum value allowed for this path. Only allowed for numbers and dates. */
-    min?: number | Date | [number, string] | [Date, string] | readonly [number, string] | readonly [Date, string];
+    min?: number | NativeDate | [number, string] | [NativeDate, string] | readonly [number, string] | readonly [NativeDate, string];
 
     /** The maximum value allowed for this path. Only allowed for numbers and dates. */
-    max?: number | Date | [number, string] | [Date, string] | readonly [number, string] | readonly [Date, string];
+    max?: number | NativeDate | [number, string] | [NativeDate, string] | readonly [number, string] | readonly [NativeDate, string];
 
     /** Defines a TTL index on this path. Only allowed for dates. */
-    expires?: number | Date;
+    expires?: number | NativeDate;
 
     /** If `true`, Mongoose will skip gathering indexes on subpaths. Only allowed for subdocuments and subdocument arrays. */
     excludeIndexes?: boolean;
@@ -1548,7 +1686,6 @@ declare module 'mongoose' {
     _id?: boolean;
 
     /** If set, specifies the type of this map's values. Mongoose will cast this map's values to the given type. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     of?: Function | SchemaDefinitionProperty<any>;
 
     /** If true, uses Mongoose's default `_id` settings. Only allowed for ObjectIds */
@@ -1703,8 +1840,8 @@ declare module 'mongoose' {
 
         static options: { castNonArrays: boolean; };
 
-        discriminator<D extends Document>(name: string | number, schema: Schema<D>, value?: string): Model<D>;
-        discriminator<T extends Document, U extends Model<T>>(name: string | number, schema: Schema<T, U>, value?: string): U;
+        discriminator<D>(name: string | number, schema: Schema<D>, value?: string): Model<D>;
+        discriminator<T, U extends Model<T>>(name: string | number, schema: Schema<T, U>, value?: string): U;
 
         /**
          * Adds an enum validator if this is an array of strings or numbers. Equivalent to
@@ -1743,10 +1880,10 @@ declare module 'mongoose' {
         expires(when: number | string): this;
 
         /** Sets a maximum date validator. */
-        max(value: Date, message: string): this;
+        max(value: NativeDate, message: string): this;
 
         /** Sets a minimum date validator. */
-        min(value: Date, message: string): this;
+        min(value: NativeDate, message: string): this;
       }
 
       class Decimal128 extends SchemaType {
@@ -1760,8 +1897,8 @@ declare module 'mongoose' {
 
         static options: { castNonArrays: boolean; };
 
-        discriminator<D extends Document>(name: string | number, schema: Schema<D>, value?: string): Model<D>;
-        discriminator<T extends Document, U extends Model<T>>(name: string | number, schema: Schema<T, U>, value?: string): U;
+        discriminator<D>(name: string | number, schema: Schema<D>, value?: string): Model<D>;
+        discriminator<T, U extends Model<T>>(name: string | number, schema: Schema<T, U>, value?: string): U;
 
         /** The schema used for documents in this array */
         schema: Schema;
@@ -1799,12 +1936,15 @@ declare module 'mongoose' {
         auto(turnOn: boolean): this;
       }
 
-      class Embedded extends SchemaType {
+      class Embedded extends SchemaType implements AcceptsDiscriminator {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: string;
 
         /** The document's schema */
         schema: Schema;
+
+        discriminator<D>(name: string | number, schema: Schema<D>, value?: string): Model<D>;
+        discriminator<T, U extends Model<T>>(name: string | number, schema: Schema<T, U>, value?: string): U;
       }
 
       class String extends SchemaType {
@@ -1972,7 +2112,6 @@ declare module 'mongoose' {
     // @todo: this doesn't seem right
     exec(callback?: (err: CallbackError, result: ResultType) => void): Promise<ResultType> | any;
 
-    // eslint-disable-next-line @typescript-eslint/ban-types
     $where(argument: string | Function): QueryWithHelpers<DocType[], DocType, THelpers, RawDocType>;
 
     /** Specifies an `$all` query condition. When called with one argument, the most recent path passed to `where()` is used. */
@@ -2051,9 +2190,7 @@ declare module 'mongoose' {
     distinct(field: string, filter?: FilterQuery<DocType>, callback?: (err: CallbackError, count: number) => void): QueryWithHelpers<Array<any>, DocType, THelpers, RawDocType>;
 
     /** Specifies a `$elemMatch` query condition. When called with one argument, the most recent path passed to `where()` is used. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     elemMatch(val: Function | any): this;
-    // eslint-disable-next-line @typescript-eslint/ban-types
     elemMatch(path: string, val: Function | any): this;
 
     /**
@@ -2172,7 +2309,7 @@ declare module 'mongoose' {
      * Runs a function `fn` and treats the return value of `fn` as the new value
      * for the query to resolve to.
      */
-    map<MappedType>(fn: (doc: DocType) => MappedType): QueryWithHelpers<ResultType extends unknown[] ? MappedType[] : MappedType, DocType, THelpers, RawDocType>;
+    map<MappedType>(fn: (doc: ResultType) => MappedType): QueryWithHelpers<MappedType, DocType, THelpers, RawDocType>;
 
     /** Specifies an `$maxDistance` query condition. When called with one argument, the most recent path passed to `where()` is used. */
     maxDistance(val: number): this;
@@ -2376,9 +2513,9 @@ declare module 'mongoose' {
     ? mongodb.Condition<T[P]>
     : mongodb.Condition<T[P] | string>;
   } &
-    mongodb.RootQuerySelector<T>;
+    mongodb.RootQuerySelector<DocumentDefinition<T>>;
 
-  export type FilterQuery<T> = _FilterQuery<DocumentDefinition<T>>;
+  export type FilterQuery<T> = _FilterQuery<T>;
 
   type NumericTypes = number | mongodb.Decimal128 | mongodb.Double | mongodb.Int32 | mongodb.Long;
 
@@ -2440,8 +2577,7 @@ declare module 'mongoose' {
 
   type actualPrimitives = string | boolean | number | bigint | symbol | null | undefined;
   type TreatAsPrimitives = actualPrimitives |
-      // eslint-disable-next-line no-undef
-    Date | RegExp | symbol | Error | BigInt | Types.ObjectId;
+    NativeDate | RegExp | symbol | Error | BigInt | Types.ObjectId;
 
   type LeanType<T> =
     0 extends (1 & T) ? T : // any
@@ -2451,13 +2587,18 @@ declare module 'mongoose' {
   type LeanArray<T extends unknown[]> = T extends unknown[][] ? LeanArray<T[number]>[] : LeanType<T[number]>[];
 
   export type _LeanDocument<T> = {
-    [K in keyof T]:
-    0 extends (1 & T[K]) ? T[K] : // any
-    T[K] extends unknown[] ? LeanArray<T[K]> : // Array
-    T[K] extends Document ? LeanDocument<T[K]> : // Subdocument
-    T[K];
+    [K in keyof T]: LeanDocumentElement<T[K]>;
   };
 
+  // Keep this a separate type, to ensure that T is a naked type.
+  // This way, the conditional type is distributive over union types.
+  // This is required for PopulatedDoc.
+  type LeanDocumentElement<T> =
+    0 extends (1 & T) ? T : // any
+    T extends unknown[] ? LeanArray<T> : // Array
+    T extends Document ? LeanDocument<T> : // Subdocument
+    T;
+
   export type LeanDocument<T> = Omit<_LeanDocument<T>, Exclude<keyof Document, '_id' | 'id' | '__v'> | '$isSingleNested'>;
 
   export type LeanDocumentOrArray<T> = 0 extends (1 & T) ? T :
@@ -2691,7 +2832,6 @@ declare module 'mongoose' {
     constructor(path: string, options?: any, instance?: string);
 
     /** Get/set the function used to cast arbitrary values to this type. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     static cast(caster?: Function | boolean): Function;
 
     static checkRequired(checkRequired?: (v: any) => boolean): (v: any) => boolean;
@@ -2712,7 +2852,6 @@ declare module 'mongoose' {
     default(val: any): any;
 
     /** Adds a getter to this schematype. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     get(fn: Function): this;
 
     /**
@@ -2740,7 +2879,6 @@ declare module 'mongoose' {
     select(val: boolean): this;
 
     /** Adds a setter to this schematype. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     set(fn: Function): this;
 
     /** Declares a sparse index. */
@@ -2756,7 +2894,6 @@ declare module 'mongoose' {
     unique(bool: boolean): this;
 
     /** Adds validator(s) for this document path. */
-    // eslint-disable-next-line @typescript-eslint/ban-types
     validate(obj: RegExp | Function | any, errorMsg?: string,
       type?: string): this;
   }

package/lib/aggregate.js

@@ -7,6 +7,7 @@
 const AggregationCursor = require('./cursor/AggregationCursor');
 const Query = require('./query');
 const applyGlobalMaxTimeMS = require('./helpers/query/applyGlobalMaxTimeMS');
+const getConstructorName = require('./helpers/getConstructorName');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
 const stringifyFunctionOperators = require('./helpers/aggregate/stringifyFunctionOperators');
 const util = require('util');
@@ -562,7 +563,7 @@ Aggregate.prototype.sort = function(arg) {
 
   const sort = {};
 
-  if (arg.constructor.name === 'Object') {
+  if (getConstructorName(arg) === 'Object') {
     const desc = ['desc', 'descending', -1];
     Object.keys(arg).forEach(function(field) {
       // If sorting by text score, skip coercing into 1/-1

package/lib/cast.js

@@ -9,6 +9,7 @@ const StrictModeError = require('./error/strict');
 const Types = require('./schema/index');
 const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
+const getConstructorName = require('./helpers/getConstructorName');
 const getSchemaDiscriminatorByValue = require('./helpers/discriminator/getSchemaDiscriminatorByValue');
 const isOperator = require('./helpers/query/isOperator');
 const util = require('util');
@@ -267,7 +268,7 @@ module.exports = function cast(schema, obj, options, context) {
         }
       } else if (val == null) {
         continue;
-      } else if (val.constructor.name === 'Object') {
+      } else if (getConstructorName(val) === 'Object') {
         any$conditionals = Object.keys(val).some(isOperator);
 
         if (!any$conditionals) {

package/lib/connection.js

@@ -652,7 +652,7 @@ Connection.prototype.onOpen = function() {
  * @param {String} uri The URI to connect with.
  * @param {Object} [options] Passed on to http://mongodb.github.io/node-mongodb-native/2.2/api/MongoClient.html#connect
  * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
- * @param {Number} [options.bufferTimeoutMS=true] Mongoose specific option. If `bufferCommands` is true, Mongoose will throw an error after `bufferTimeoutMS` if the operation is still buffered.
+ * @param {Number} [options.bufferTimeoutMS=10000] Mongoose specific option. If `bufferCommands` is true, Mongoose will throw an error after `bufferTimeoutMS` if the operation is still buffered.
  * @param {String} [options.dbName] The name of the database we want to use. If not provided, use database name from connection string.
  * @param {String} [options.user] username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility.
  * @param {String} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.

package/lib/cursor/QueryCursor.js

@@ -55,6 +55,9 @@ function QueryCursor(query, options) {
     if (this.options.batchSize) {
       this.options.cursor = options.cursor || {};
       this.options.cursor.batchSize = options.batchSize;
+
+      // Max out the number of documents we'll populate in parallel at 5000.
+      this.options._populateBatchSize = Math.min(this.options.batchSize, 5000);
     }
     model.collection.find(query._conditions, this.options, function(err, cursor) {
       if (_this._error) {
@@ -360,7 +363,7 @@ function _next(ctx, cb) {
         ctx.query._mongooseOptions);
       ctx._pop.__noPromise = true;
     }
-    if (ctx.query._mongooseOptions.populate && ctx.options.batchSize > 1) {
+    if (ctx.query._mongooseOptions.populate && ctx.options._populateBatchSize > 1) {
       if (ctx._batchDocs && ctx._batchDocs.length) {
         // Return a cached populated doc
         return _nextDoc(ctx, ctx._batchDocs.shift(), ctx._pop, callback);
@@ -418,7 +421,12 @@ function _onNext(error, doc) {
 
   this.ctx._batchDocs.push(doc);
 
-  if (this.ctx._batchDocs.length < this.ctx.options.batchSize) {
+  if (this.ctx._batchDocs.length < this.ctx.options._populateBatchSize) {
+    // If both `batchSize` and `_populateBatchSize` are huge, calling `next()` repeatedly may
+    // cause a stack overflow. So make sure we clear the stack regularly.
+    if (this.ctx._batchDocs.length > 0 && this.ctx._batchDocs.length % 1000 === 0) {
+      return immediate(() => this.ctx.cursor.next(_onNext.bind(this)));
+    }
     this.ctx.cursor.next(_onNext.bind(this));
   } else {
     _populateBatch.call(this);

package/lib/document.js

@@ -994,6 +994,9 @@ Document.prototype.$set = function $set(path, val, type, options) {
         delete this._doc[key];
         // Make sure we set `{}` back even if we minimize re: gh-8565
         options = Object.assign({}, options, { _skipMinimizeTopLevel: true });
+      } else {
+        // Make sure we set `{_skipMinimizeTopLevel: false}` if don't have overwrite: gh-10441
+        options = Object.assign({}, options, { _skipMinimizeTopLevel: false });
       }
 
       const someCondition = typeof path[key] === 'object' &&
@@ -4143,7 +4146,7 @@ Document.prototype.populated = function(path, val, options) {
  *       console.log(doc.author); // '5144cf8050f071d979c118a7'
  *     })
  *
- * If the path was not populated, this is a no-op.
+ * If the path was not provided, then all populated fields are returned to their unpopulated state.
  *
  * @param {String} path
  * @return {Document} this

package/lib/drivers/node-mongodb-native/collection.js

@@ -9,6 +9,7 @@ const MongooseError = require('../../error/mongooseError');
 const Collection = require('mongodb').Collection;
 const ObjectId = require('./objectid');
 const get = require('../../helpers/get');
+const getConstructorName = require('../../helpers/getConstructorName');
 const sliced = require('sliced');
 const stream = require('stream');
 const util = require('util');
@@ -376,14 +377,15 @@ function format(obj, sub, color, shell) {
 
   const clone = require('../../helpers/clone');
   let x = clone(obj, { transform: false });
+  const constructorName = getConstructorName(x);
 
-  if (x.constructor.name === 'Binary') {
+  if (constructorName === 'Binary') {
     x = 'BinData(' + x.sub_type + ', "' + x.toString('base64') + '")';
-  } else if (x.constructor.name === 'ObjectID') {
+  } else if (constructorName === 'ObjectID') {
     x = inspectable('ObjectId("' + x.toHexString() + '")');
-  } else if (x.constructor.name === 'Date') {
+  } else if (constructorName === 'Date') {
     x = inspectable('new Date("' + x.toUTCString() + '")');
-  } else if (x.constructor.name === 'Object') {
+  } else if (constructorName === 'Object') {
     const keys = Object.keys(x);
     const numKeys = keys.length;
     let key;
@@ -402,16 +404,17 @@ function format(obj, sub, color, shell) {
             error = _error;
           }
         }
-        if (x[key].constructor.name === 'Binary') {
+        const _constructorName = getConstructorName(x[key]);
+        if (_constructorName === 'Binary') {
           x[key] = 'BinData(' + x[key].sub_type + ', "' +
             x[key].buffer.toString('base64') + '")';
-        } else if (x[key].constructor.name === 'Object') {
+        } else if (_constructorName === 'Object') {
           x[key] = format(x[key], true);
-        } else if (x[key].constructor.name === 'ObjectID') {
+        } else if (_constructorName === 'ObjectID') {
           formatObjectId(x, key);
-        } else if (x[key].constructor.name === 'Date') {
+        } else if (_constructorName === 'Date') {
           formatDate(x, key, shell);
-        } else if (x[key].constructor.name === 'ClientSession') {
+        } else if (_constructorName === 'ClientSession') {
           x[key] = inspectable('ClientSession("' +
             get(x[key], 'id.id.buffer', '').toString('hex') + '")');
         } else if (Array.isArray(x[key])) {

package/lib/error/validation.js

@@ -5,6 +5,7 @@
 'use strict';
 
 const MongooseError = require('./mongooseError');
+const getConstructorName = require('../helpers/getConstructorName');
 const util = require('util');
 
 class ValidationError extends MongooseError {
@@ -17,7 +18,7 @@ class ValidationError extends MongooseError {
    */
   constructor(instance) {
     let _message;
-    if (instance && instance.constructor.name === 'model') {
+    if (getConstructorName(instance) === 'model') {
       _message = instance.constructor.modelName + ' validation failed';
     } else {
       _message = 'Validation failed';