mongoose 5.11.13 → 5.11.17

package/index.d.ts

@@ -546,7 +546,7 @@ declare module 'mongoose' {
     populated(path: string): any;
 
     /** Removes this document from the db. */
-    remove(options?: QueryOptions): Query<any, this>;
+    remove(options?: QueryOptions): Promise<this>;
     remove(options?: QueryOptions, cb?: (err: CallbackError, res: any) => void): void;
 
     /** Sends a replaceOne command with this document `_id` as the query selector. */
@@ -630,11 +630,11 @@ declare module 'mongoose' {
     countDocuments(filter: FilterQuery<T>, callback?: (err: any, count: number) => void): Query<number, T>;
 
     /** Creates a new document or documents */
-    create<DocContents = T | DocumentDefinition<T>>(doc: DocContents): Promise<T>;
     create<DocContents = T | DocumentDefinition<T>>(docs: DocContents[], options?: SaveOptions): Promise<T[]>;
+    create<DocContents = T | DocumentDefinition<T>>(doc: DocContents): Promise<T>;
     create<DocContents = T | DocumentDefinition<T>>(...docs: DocContents[]): Promise<T[]>;
-    create<DocContents = T | DocumentDefinition<T>>(doc: DocContents, callback: (err: CallbackError, doc: T) => void): void;
     create<DocContents = T | DocumentDefinition<T>>(docs: DocContents[], callback: (err: CallbackError, docs: T[]) => void): void;
+    create<DocContents = T | DocumentDefinition<T>>(doc: DocContents, callback: (err: CallbackError, doc: T) => void): void;
 
     /**
      * Create the collection for this model. By default, if no indexes are specified,
@@ -753,6 +753,7 @@ declare module 'mongoose' {
     /** Casts and validates the given object against this model's schema, passing the given `context` to custom validators. */
     validate(callback?: (err: any) => void): Promise<void>;
     validate(optional: any, callback?: (err: any) => void): Promise<void>;
+    validate(optional: any, pathsToValidate: string[], callback?: (err: any) => void): Promise<void>;
 
     /** Watches the underlying collection for changes using [MongoDB change streams](https://docs.mongodb.com/manual/changeStreams/). */
     watch(pipeline?: Array<Record<string, unknown>>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream;
@@ -844,6 +845,8 @@ declare module 'mongoose' {
 
     /** Creates a Query, applies the passed conditions, and returns the Query. */
     where(path: string, val?: any): Query<Array<T>, T>;
+    where(obj: object): Query<Array<T>, T>;
+    where(): Query<Array<T>, T>;
   }
 
   interface QueryOptions {
@@ -1037,16 +1040,20 @@ declare module 'mongoose' {
     useProjection?: boolean;
   }
 
+  type MongooseDocumentMiddleware = 'validate' | 'save' | 'remove' | 'updateOne' | 'deleteOne' | 'init';
   type MongooseQueryMiddleware = 'count' | 'deleteMany' | 'deleteOne' | 'find' | 'findOne' | 'findOneAndDelete' | 'findOneAndRemove' | 'findOneAndUpdate' | 'remove' | 'update' | 'updateOne' | 'updateMany';
 
-  class Schema<DocType extends Document = Document, M extends Model<DocType> = Model<DocType>> extends events.EventEmitter {
+  type SchemaPreOptions = { document?: boolean, query?: boolean };
+  type SchemaPostOptions = { document?: boolean, query?: boolean };
+
+  class Schema<DocType extends Document = Document, M extends Model<DocType> = Model<DocType>, SchemaDefinitionType = undefined> extends events.EventEmitter {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition, options?: SchemaOptions);
+    constructor(definition?: SchemaDefinition<DocumentDefinition<SchemaDefinitionType>>, options?: SchemaOptions);
 
     /** Adds key path / schema type pairs to this schema. */
-    add(obj: SchemaDefinition | Schema, prefix?: string): this;
+    add(obj: SchemaDefinition<DocumentDefinition<SchemaDefinitionType>> | Schema, prefix?: string): this;
 
     /**
      * Array of child schemas (from document arrays and single nested subdocs)
@@ -1113,21 +1120,33 @@ declare module 'mongoose' {
     plugin(fn: (schema: Schema, opts?: any) => void, opts?: any): this;
 
     /** Defines a post hook for the model. */
-    post<T extends Document = DocType>(method: 'validate' | 'save' | 'remove' | 'updateOne' | 'deleteOne' | 'init' | RegExp, fn: (this: T, res: any, next: (err?: CallbackError) => void) => void): this;
-    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | string | RegExp, fn: (this: T, res: any, next: (err: CallbackError) => void) => void): this;
+    post<T extends Document = DocType>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: (this: T, res: any, next: (err?: CallbackError) => void) => void): this;
+    post<T extends Document = DocType>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: (this: T, res: any, next: (err?: CallbackError) => void) => void): this;
+    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: (this: T, res: any, next: (err: CallbackError) => void) => void): this;
+    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: (this: T, res: any, next: (err: CallbackError) => void) => void): this;
     post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, fn: (this: T, res: Array<any>, next: (err: CallbackError) => void) => void): this;
+    post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: (this: T, res: Array<any>, next: (err: CallbackError) => void) => void): this;
     post<T extends Model<DocType> = M>(method: 'insertMany' | RegExp, fn: (this: T, res: any, next: (err: CallbackError) => void) => void): this;
+    post<T extends Model<DocType> = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: (this: T, res: any, next: (err: CallbackError) => void) => void): this;
 
-    post<T extends Document = DocType>(method: 'validate' | 'save' | 'remove' | 'updateOne' | 'deleteOne' | 'init' | RegExp, fn: (this: T, err: NativeError, res: any, next: (err?: CallbackError) => void) => void): this;
-    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | string | RegExp, fn: (this: T, err: NativeError, res: any, next: (err: CallbackError) => void) => void): this;
+    post<T extends Document = DocType>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: (this: T, err: NativeError, res: any, next: (err?: CallbackError) => void) => void): this;
+    post<T extends Document = DocType>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: (this: T, err: NativeError, res: any, next: (err?: CallbackError) => void) => void): this;
+    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: (this: T, err: NativeError, res: any, next: (err: CallbackError) => void) => void): this;
+    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: (this: T, err: NativeError, res: any, next: (err: CallbackError) => void) => void): this;
     post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, fn: (this: T, err: NativeError, res: Array<any>, next: (err: CallbackError) => void) => void): this;
+    post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: (this: T, err: NativeError, res: Array<any>, next: (err: CallbackError) => void) => void): this;
     post<T extends Model<DocType> = M>(method: 'insertMany' | RegExp, fn: (this: T, err: NativeError, res: any, next: (err: CallbackError) => void) => void): this;
+    post<T extends Model<DocType> = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: (this: T, err: NativeError, res: any, next: (err: CallbackError) => void) => void): this;
 
     /** Defines a pre hook for the model. */
-    pre<T extends Document = DocType>(method: 'validate' | 'save' | 'remove' | 'updateOne' | 'deleteOne' | 'init' | RegExp, fn: (this: T, next: (err?: CallbackError) => void) => void): this;
-    pre<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | string | RegExp, fn: (this: T, next: (err: CallbackError) => void) => void): this;
+    pre<T extends Document = DocType>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: (this: T, next: (err?: CallbackError) => void) => void): this;
+    pre<T extends Document = DocType>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err?: CallbackError) => void) => void): this;
+    pre<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: (this: T, next: (err: CallbackError) => void) => void): this;
+    pre<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err: CallbackError) => void) => void): this;
     pre<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, fn: (this: T, next: (err: CallbackError) => void) => void): this;
+    pre<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err: CallbackError) => void) => void): this;
     pre<T extends Model<DocType> = M>(method: 'insertMany' | RegExp, fn: (this: T, next: (err: CallbackError) => void) => void): this;
+    pre<T extends Model<DocType> = M>(method: 'insertMany' | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err: CallbackError) => void) => void): this;
 
     /** Object of currently defined query helpers on this schema. */
     query: any;
@@ -1163,11 +1182,17 @@ declare module 'mongoose' {
     virtualpath(name: string): VirtualType | null;
   }
 
+  type SchemaDefinitionWithBuiltInClass<T> = T extends number
+    ? (typeof Number | 'number' | 'Number')
+    : T extends string
+    ? (typeof String | 'string' | 'String')
+    : (Function | string);
+
   type SchemaDefinitionProperty<T = undefined> = SchemaTypeOptions<T extends undefined ? any : T> |
-    Function |
-    string |
-    Schema |
-    Schema[] |
+    SchemaDefinitionWithBuiltInClass<T> |
+    typeof SchemaType |
+    Schema<T extends Document ? T : Document<any>> |
+    Schema<T extends Document ? T : Document<any>>[] |
     SchemaTypeOptions<T extends undefined ? any : T>[] |
     Function[] |
     SchemaDefinition<T> |
@@ -1175,7 +1200,7 @@ declare module 'mongoose' {
 
   type SchemaDefinition<T = undefined> = T extends undefined
     ? { [path: string]: SchemaDefinitionProperty; }
-    : { [path in keyof T]-?: SchemaDefinitionProperty<T[path]>; };
+    : { [path in keyof T]?: SchemaDefinitionProperty<T[path]>; };
 
   interface SchemaOptions {
     /**
@@ -1340,7 +1365,7 @@ declare module 'mongoose' {
   }
 
   interface SchemaTypeOptions<T> {
-    type?: T;
+    type?: T | SchemaDefinitionWithBuiltInClass<T>;
 
     /** Defines a virtual with the given name that gets/sets this path. */
     alias?: string;
@@ -1357,7 +1382,7 @@ declare module 'mongoose' {
      * path cannot be set to a nullish value. If a function, Mongoose calls the
      * function and only checks for nullish values if the function returns a truthy value.
      */
-    required?: boolean | (() => boolean) | [boolean, string];
+    required?: boolean | (() => boolean) | [boolean, string] | [() => boolean, string];
 
     /**
      * The default value for this path. If a function, Mongoose executes the function
@@ -1421,7 +1446,7 @@ declare module 'mongoose' {
     set?: (value: T, schematype?: this) => any;
 
     /** array of allowed values for this path. Allowed for strings, numbers, and arrays of strings */
-    enum?: Array<string | number | null>
+    enum?: Array<string | number | null> | { [path: string]: string | number | null };
 
     /** The default [subtype](http://bsonspec.org/spec.html) associated with this buffer when it is stored in MongoDB. Only allowed for buffer paths */
     subtype?: number
@@ -1769,7 +1794,7 @@ declare module 'mongoose' {
 
   type ReturnsNewDoc = { new: true } | { returnOriginal: false };
 
-  interface Query<ResultType, DocType extends Document> {
+  class Query<ResultType, DocType extends Document> {
     _mongooseOptions: MongooseQueryOptions;
 
     /** Executes the query */
@@ -2147,6 +2172,8 @@ declare module 'mongoose' {
 
     /** Specifies a path for use with chaining. */
     where(path: string, val?: any): this;
+    where(obj: object): this;
+    where(): this;
 
     /** Defines a `$within` or `$geoWithin` argument for geo-spatial queries. */
     within(val?: any): this;

package/lib/aggregate.js

@@ -8,7 +8,7 @@ const AggregationCursor = require('./cursor/AggregationCursor');
 const Query = require('./query');
 const applyGlobalMaxTimeMS = require('./helpers/query/applyGlobalMaxTimeMS');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
-const stringifyAccumulatorOptions = require('./helpers/aggregate/stringifyAccumulatorOptions');
+const stringifyFunctionOperators = require('./helpers/aggregate/stringifyFunctionOperators');
 const util = require('util');
 const utils = require('./utils');
 const read = Query.prototype.read;
@@ -983,7 +983,7 @@ Aggregate.prototype.exec = function(callback) {
 
   return promiseOrCallback(callback, cb => {
     prepareDiscriminatorPipeline(this);
-    stringifyAccumulatorOptions(this._pipeline);
+    stringifyFunctionOperators(this._pipeline);
 
     model.hooks.execPre('aggregate', this, error => {
       if (error) {

package/lib/connection.js

@@ -469,7 +469,7 @@ Connection.prototype.startSession = _wrapConnHelper(function startSession(option
  * @method transaction
  * @param {Function} fn Function to execute in a transaction
  * @param {mongodb.TransactionOptions} [options] Optional settings for the transaction
- * @return {Promise<Any>} promise that resolves to the returned value of `fn`
+ * @return {Promise<Any>} promise that is fulfilled if Mongoose successfully committed the transaction, or rejects if the transaction was aborted or if Mongoose failed to commit the transaction. If fulfilled, the promise resolves to a MongoDB command result.
  * @api public
  */
 

package/lib/document.js

@@ -41,7 +41,6 @@ const isMongooseObject = utils.isMongooseObject;
 const arrayAtomicsBackupSymbol = Symbol('mongoose.Array#atomicsBackup');
 const arrayAtomicsSymbol = require('./helpers/symbols').arrayAtomicsSymbol;
 const documentArrayParent = require('./helpers/symbols').documentArrayParent;
-const documentIsSelected = require('./helpers/symbols').documentIsSelected;
 const documentIsModified = require('./helpers/symbols').documentIsModified;
 const documentModifiedPaths = require('./helpers/symbols').documentModifiedPaths;
 const documentSchemaSymbol = require('./helpers/symbols').documentSchemaSymbol;
@@ -141,7 +140,6 @@ function Document(obj, fields, skipId, options) {
       });
     }
   }
-
   if (obj) {
     // Skip set hooks
     if (this.$__original_set) {
@@ -665,7 +663,7 @@ function init(self, obj, doc, opts, prefix) {
     // Should still work if not a model-level discriminator, but should not be
     // necessary. This is *only* to catch the case where we queried using the
     // base model and the discriminated model has a projection
-    if (self.schema.$isRootDiscriminator && !self.isSelected(path)) {
+    if (self.schema.$isRootDiscriminator && !self.$__isSelected(path)) {
       return;
     }
 
@@ -900,6 +898,7 @@ Document.prototype.overwrite = function overwrite(obj) {
  */
 
 Document.prototype.$set = function $set(path, val, type, options) {
+
   if (utils.isPOJO(type)) {
     options = type;
     type = undefined;
@@ -938,9 +937,13 @@ Document.prototype.$set = function $set(path, val, type, options) {
         path = path._doc;
       }
     }
+    if (path == null) {
+      const _ = path;
+      path = val;
+      val = _;
+    }
 
     prefix = val ? val + '.' : '';
-
     keys = Object.keys(path);
     const len = keys.length;
 
@@ -1140,7 +1143,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       // traverse the element ({nested: null})` is not likely. If user gets
       // that error, its their fault for now. We should reconsider disallowing
       // modifying not selected paths for 6.x
-      if (!this.isSelected(curPath)) {
+      if (!this.$__isSelected(curPath)) {
         this.unmarkModified(curPath);
       }
       cur = this.$__getValue(curPath);
@@ -1421,7 +1424,7 @@ Document.prototype.$__shouldModify = function(pathToMark, path, constructing, pa
     return false;
   }
 
-  if (val === void 0 && !this.isSelected(path)) {
+  if (val === void 0 && !this.$__isSelected(path)) {
     // when a path is not selected in a query, its initial
     // value will be undefined.
     return true;
@@ -2062,7 +2065,7 @@ Document.prototype.isSelected = function isSelected(path) {
     path = path.split(' ');
   }
   if (Array.isArray(path)) {
-    return path.some(p => this.isSelected(p));
+    return path.some(p => this.$__isSelected(p));
   }
 
   const paths = Object.keys(this.$__.selected);
@@ -2111,7 +2114,7 @@ Document.prototype.isSelected = function isSelected(path) {
   return !inclusive;
 };
 
-Document.prototype[documentIsSelected] = Document.prototype.isSelected;
+Document.prototype.$__isSelected = Document.prototype.isSelected;
 
 /**
  * Checks if `path` was explicitly selected. If no projection, always returns
@@ -2257,10 +2260,9 @@ function _getPathsToValidate(doc) {
   const skipSchemaValidators = {};
 
   _evaluateRequiredFunctions(doc);
-
   // only validate required fields when necessary
   let paths = new Set(Object.keys(doc.$__.activePaths.states.require).filter(function(path) {
-    if (!doc.isSelected(path) && !doc.isModified(path)) {
+    if (!doc.$__isSelected(path) && !doc.isModified(path)) {
       return false;
     }
     if (path in doc.$__.cachedRequired) {
@@ -2341,7 +2343,6 @@ function _getPathsToValidate(doc) {
     }
   }
 
-
   for (const path of paths) {
     // Single nested paths (paths embedded under single nested subdocs) will
     // be validated on their own when we call `validate()` on the subdoc itself.
@@ -2435,11 +2436,9 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
     pathDetails[0].filter((path) => this.isModified(path)) :
     pathDetails[0];
   const skipSchemaValidators = pathDetails[1];
-
   if (Array.isArray(pathsToValidate)) {
     paths = _handlePathsToValidate(paths, pathsToValidate);
   }
-
   if (paths.length === 0) {
     return process.nextTick(function() {
       const error = _complete();
@@ -2607,7 +2606,6 @@ Document.prototype.validateSync = function(pathsToValidate, options) {
   if (Array.isArray(pathsToValidate)) {
     paths = _handlePathsToValidate(paths, pathsToValidate);
   }
-
   const validating = {};
 
   paths.forEach(function(path) {
@@ -3569,7 +3567,7 @@ function applyGetters(self, json, options) {
     let part;
     cur = self._doc;
 
-    if (!self.isSelected(path)) {
+    if (!self.$__isSelected(path)) {
       continue;
     }
 
@@ -4135,7 +4133,6 @@ Document.prototype.$__fullPath = function(path) {
 
 Document.prototype.getChanges = function() {
   const delta = this.$__delta();
-
   const changes = delta ? delta[1] : {};
   return changes;
 };

package/lib/error/validation.js

@@ -67,13 +67,14 @@ if (util.inspect.custom) {
 
 /*!
  * Helper for JSON.stringify
+ * Ensure `name` and `message` show up in toJSON output re: gh-9847
  */
 Object.defineProperty(ValidationError.prototype, 'toJSON', {
   enumerable: false,
   writable: false,
   configurable: true,
   value: function() {
-    return Object.assign({}, this, { message: this.message });
+    return Object.assign({}, this, { name: this.name, message: this.message });
   }
 });
 

package/lib/helpers/aggregate/{stringifyAccumulatorOptions.js → stringifyFunctionOperators.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-module.exports = function stringifyAccumulatorOptions(pipeline) {
+module.exports = function stringifyFunctionOperators(pipeline) {
   if (!Array.isArray(pipeline)) {
     return;
   }
@@ -17,9 +17,21 @@ module.exports = function stringifyAccumulatorOptions(pipeline) {
       }
     }
 
+    const stageType = Object.keys(stage)[0];
+    if (stageType && typeof stage[stageType] === 'object') {
+      const stageOptions = stage[stageType];
+      for (const key of Object.keys(stageOptions)) {
+        if (stageOptions[key] != null &&
+            stageOptions[key].$function != null &&
+            typeof stageOptions[key].$function.body === 'function') {
+          stageOptions[key].$function.body = stageOptions[key].$function.body.toString();
+        }
+      }
+    }
+
     if (stage.$facet != null) {
       for (const key of Object.keys(stage.$facet)) {
-        stringifyAccumulatorOptions(stage.$facet[key]);
+        stringifyFunctionOperators(stage.$facet[key]);
       }
     }
   }

package/lib/helpers/clone.js

@@ -111,7 +111,7 @@ function cloneObject(obj, options, isArrayChild) {
   const ret = {};
   let hasKeys;
 
-  for (const k in obj) {
+  for (const k of Object.keys(obj)) {
     if (specialProperties.has(k)) {
       continue;
     }

package/lib/helpers/populate/assignVals.js

@@ -240,7 +240,7 @@ function valueFilter(val, assignmentOpts, populateOptions) {
   if (populateOptions.justOne === false) {
     return [];
   }
-  return val;
+  return val == null ? val : null;
 }
 
 /*!

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -43,7 +43,6 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
   for (i = 0; i < len; i++) {
     doc = docs[i];
     let justOne = null;
-
     schema = getSchemaTypes(modelSchema, doc, options.path);
     // Special case: populating a path that's a DocumentArray unless
     // there's an explicit `ref` or `refPath` re: gh-8946
@@ -174,9 +173,11 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
       }
     } else if (schema && !schema[schemaMixedSymbol]) {
       // Skip Mixed types because we explicitly don't do casting on those.
-      justOne = Array.isArray(schema) ?
-        schema.every(schema => !schema.$isMongooseArray) :
-        !schema.$isMongooseArray;
+      if (options.path.endsWith('.' + schema.path)) {
+        justOne = Array.isArray(schema) ?
+          schema.every(schema => !schema.$isMongooseArray) :
+          !schema.$isMongooseArray;
+      }
     }
 
     if (!modelNames) {
@@ -358,7 +359,6 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
       }
     }
   }
-
   return map;
 
   function _getModelNames(doc, schema) {

package/lib/helpers/populate/getSchemaTypes.js

@@ -20,7 +20,6 @@ const populateModelSymbol = require('../symbols').populateModelSymbol;
 module.exports = function getSchemaTypes(schema, doc, path) {
   const pathschema = schema.path(path);
   const topLevelDoc = doc;
-
   if (pathschema) {
     return pathschema;
   }
@@ -33,7 +32,6 @@ module.exports = function getSchemaTypes(schema, doc, path) {
     while (p--) {
       trypath = parts.slice(0, p).join('.');
       foundschema = schema.path(trypath);
-
       if (foundschema == null) {
         continue;
       }
@@ -117,7 +115,6 @@ module.exports = function getSchemaTypes(schema, doc, path) {
               ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
                 !foundschema.schema.$isSingleNested;
             }
-
             return ret;
           }
         } else if (p !== parts.length &&
@@ -153,7 +150,6 @@ module.exports = function getSchemaTypes(schema, doc, path) {
             ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
               !model.schema.$isSingleNested;
           }
-
           return ret;
         }
       }
@@ -177,15 +173,12 @@ module.exports = function getSchemaTypes(schema, doc, path) {
             ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
               !schema.$isSingleNested;
           }
-
           return ret;
         }
       }
-
       return foundschema;
     }
   }
-
   // look for arrays
   const parts = path.split('.');
   for (let i = 0; i < parts.length; ++i) {

package/lib/helpers/query/castFilterPath.js

@@ -25,7 +25,7 @@ module.exports = function castFilterPath(query, schematype, val) {
       if (nested && schematype && !schematype.caster) {
         const _keys = Object.keys(nested);
         if (_keys.length && isOperator(_keys[0])) {
-          for (const key in nested) {
+          for (const key of Object.keys(nested)) {
             nested[key] = schematype.castForQueryWrapper({
               $conditional: key,
               val: nested[key],

package/lib/helpers/timestamps/setupTimestamps.js

@@ -51,7 +51,7 @@ module.exports = function setupTimestamps(schema, timestamps) {
       (this.ownerDocument ? this.ownerDocument() : this).constructor.base.now();
     const auto_id = this._id && this._id.auto;
 
-    if (!skipCreatedAt && createdAt && !this.get(createdAt) && this.isSelected(createdAt)) {
+    if (!skipCreatedAt && createdAt && !this.get(createdAt) && this.$__isSelected(createdAt)) {
       this.$set(createdAt, auto_id ? this._id.getTimestamp() : defaultTimestamp);
     }
 

package/lib/helpers/update/castArrayFilters.js

@@ -38,8 +38,7 @@ module.exports = function castArrayFilters(query) {
     if (filter == null) {
       throw new Error(`Got null array filter in ${arrayFilters}`);
     }
-    for (const key in filter) {
-
+    for (const key of Object.keys(filter)) {
       if (filter[key] == null) {
         continue;
       }

package/lib/model.js

@@ -538,7 +538,6 @@ function operand(self, where, delta, data, val, op) {
   op || (op = '$set');
   if (!delta[op]) delta[op] = {};
   delta[op][data.path] = val;
-
   // disabled versioning?
   if (self.schema.options.versionKey === false) return;
 
@@ -748,7 +747,6 @@ Model.prototype.$__delta = function() {
   if (this.$__.version) {
     this.$__version(where, delta);
   }
-
   return [where, delta];
 };
 
@@ -825,7 +823,7 @@ Model.prototype.$__version = function(where, delta) {
   // there is no way to select the correct version. we could fail
   // fast here and force them to include the versionKey but
   // thats a bit intrusive. can we do this automatically?
-  if (!this.isSelected(key)) {
+  if (!this.$__isSelected(key)) {
     return;
   }
 
@@ -1652,6 +1650,10 @@ function _ensureIndexes(model, options, callback) {
     if ('background' in options) {
       indexOptions.background = options.background;
     }
+    if (model.schema.options.hasOwnProperty('collation') &&
+        !indexOptions.hasOwnProperty('collation')) {
+      indexOptions.collation = model.schema.options.collation;
+    }
 
     const methodName = useCreateIndex ? 'createIndex' : 'ensureIndex';
     model.collection[methodName](indexFields, indexOptions, utils.tick(function(err, name) {
@@ -4338,7 +4340,6 @@ function populate(model, docs, options, callback) {
   }
 
   const modelsMap = getModelsMapForPopulate(model, docs, options);
-
   if (modelsMap instanceof MongooseError) {
     return immediate(function() {
       callback(modelsMap);
@@ -4422,7 +4423,6 @@ function populate(model, docs, options, callback) {
     } else if (mod.options.limit != null) {
       assignmentOpts.originalLimit = mod.options.limit;
     }
-
     params.push([mod, match, select, assignmentOpts, _next]);
   }
 
@@ -4441,7 +4441,6 @@ function populate(model, docs, options, callback) {
   for (const arr of params) {
     _execPopulateQuery.apply(null, arr);
   }
-
   function _next(err, valsFromDb) {
     if (err != null) {
       return callback(err, null);
@@ -4475,7 +4474,6 @@ function populate(model, docs, options, callback) {
 
 function _execPopulateQuery(mod, match, select, assignmentOpts, callback) {
   const subPopulate = utils.clone(mod.options.populate);
-
   const queryOptions = Object.assign({
     skip: mod.options.skip,
     limit: mod.options.limit,
@@ -4594,7 +4592,12 @@ function _assign(model, vals, mod, assignmentOpts) {
           if (Array.isArray(rawDocs[key])) {
             rawDocs[key].push(val);
             rawOrder[key].push(i);
-          } else {
+          } else if (isVirtual ||
+            rawDocs[key].constructor !== val.constructor ||
+            String(rawDocs[key]._id) !== String(val._id)) {
+            // May need to store multiple docs with the same id if there's multiple models
+            // if we have discriminators or a ref function. But avoid converting to an array
+            // if we have multiple queries on the same model because of `perDocumentLimit` re: gh-9906
             rawDocs[key] = [rawDocs[key], val];
             rawOrder[key] = [rawOrder[key], i];
           }

package/lib/query.js

@@ -1397,9 +1397,11 @@ Query.prototype.setOptions = function(options, overwrite) {
 Query.prototype.explain = function(verbose) {
   if (arguments.length === 0) {
     this.options.explain = true;
-    return this;
+  } else if (verbose === false) {
+    delete this.options.explain;
+  } else {
+    this.options.explain = verbose;
   }
-  this.options.explain = verbose;
   return this;
 };
 
@@ -4964,7 +4966,7 @@ Query.prototype.tailable = function(val, opts) {
   }
 
   if (opts && typeof opts === 'object') {
-    for (const key in opts) {
+    for (const key of Object.keys(opts)) {
       if (key === 'awaitdata') {
         // For backwards compatibility
         this.options[key] = !!opts[key];

package/lib/schema/SingleNestedPath.js

@@ -147,7 +147,7 @@ SingleNestedPath.prototype.$conditionalHandlers.$exists = $exists;
  * @api private
  */
 
-SingleNestedPath.prototype.cast = function(val, doc, init, priorVal) {
+SingleNestedPath.prototype.cast = function(val, doc, init, priorVal, options) {
   if (val && val.$isSingleNested && val.parent === doc) {
     return val;
   }
@@ -169,16 +169,16 @@ SingleNestedPath.prototype.cast = function(val, doc, init, priorVal) {
     }
     return obj;
   }, {});
-
+  options = Object.assign({}, options, { priorDoc: priorVal });
   if (init) {
     subdoc = new Constructor(void 0, selected, doc);
     subdoc.init(val);
   } else {
     if (Object.keys(val).length === 0) {
-      return new Constructor({}, selected, doc, undefined, { priorDoc: priorVal });
+      return new Constructor({}, selected, doc, undefined, options);
     }
 
-    return new Constructor(val, selected, doc, undefined, { priorDoc: priorVal });
+    return new Constructor(val, selected, doc, undefined, options);
   }
 
   return subdoc;