mongoose 6.1.2 → 6.1.6

package/index.d.ts

@@ -77,6 +77,10 @@ declare module 'mongoose' {
   export function syncIndexes(options?: Record<string, unknown>): Promise<Array<string>>;
   export function syncIndexes(options: Record<string, unknown> | null, callback: Callback<Array<string>>): void;
 
+  /* Tells `sanitizeFilter()` to skip the given object when filtering out potential query selector injection attacks.
+   * Use this method when you have a known query selector that you want to use. */
+  export function trusted<T>(obj: T): T;
+
   /** The Mongoose module's default connection. Equivalent to `mongoose.connections[0]`, see [`connections`](#mongoose_Mongoose-connections). */
   export const connection: Connection;
 
@@ -763,7 +767,7 @@ declare module 'mongoose' {
 
   export const Model: Model<any>;
   interface Model<T, TQueryHelpers = {}, TMethods = {}, TVirtuals = {}> extends NodeJS.EventEmitter, AcceptsDiscriminator {
-    new(doc?: AnyKeys<T> & AnyObject, fields?: any | null, options?: boolean | AnyObject): HydratedDocument<T, TMethods, TVirtuals>;
+    new<DocType = AnyKeys<T> & AnyObject>(doc?: DocType, fields?: any | null, options?: boolean | AnyObject): HydratedDocument<T, TMethods, TVirtuals>;
 
     aggregate<R = any>(pipeline?: PipelineStage[], options?: mongodb.AggregateOptions, callback?: Callback<R[]>): Aggregate<Array<R>>;
     aggregate<R = any>(pipeline: PipelineStage[], cb: Function): Aggregate<Array<R>>;
@@ -1217,7 +1221,7 @@ declare module 'mongoose' {
     /** optional query options like sort, limit, etc */
     options?: any;
     /** deep populate */
-    populate?: PopulateOptions | Array<PopulateOptions>;
+    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.
@@ -1254,7 +1258,6 @@ declare module 'mongoose' {
   type SchemaPreOptions = { document?: boolean, query?: boolean };
   type SchemaPostOptions = { document?: boolean, query?: boolean };
 
-  type ExtractQueryHelpers<M> = M extends Model<any, infer TQueryHelpers, any, any> ? TQueryHelpers : {};
   type ExtractVirtuals<M> = M extends Model<any, any, any, infer TVirtuals> ? TVirtuals : {};
 
   type IndexDirection = 1 | -1 | '2d' | '2dsphere' | 'geoHaystack' | 'hashed' | 'text';
@@ -1265,7 +1268,7 @@ declare module 'mongoose' {
   type PostMiddlewareFunction<ThisType, ResType = any> = (this: ThisType, res: ResType, next: (err?: CallbackError) => void) => void | Promise<void>;
   type ErrorHandlingMiddlewareFunction<ThisType, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: (err?: CallbackError) => void) => void;
 
-  class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = any> extends events.EventEmitter {
+  class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = any, TQueryHelpers = any> extends events.EventEmitter {
     /**
      * Create a new schema
      */
@@ -1312,11 +1315,11 @@ declare module 'mongoose' {
     loadClass(model: Function, onlyVirtuals?: boolean): this;
 
     /** Adds an instance method to documents constructed from Models compiled from this schema. */
-    method(name: string, fn: (this: HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>, ...args: any[]) => any, opts?: any): this;
-    method(obj: { [name: string]: (this: HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>, ...args: any[]) => any }): this;
+    method<Context = any>(name: string, fn: (this: Context, ...args: any[]) => any, opts?: any): this;
+    method(obj: Partial<TInstanceMethods>): this;
 
     /** Object of currently defined methods on this schema. */
-    methods: { [name: string]: (this: HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>, ...args: any[]) => any };
+    methods: { [F in keyof TInstanceMethods]: TInstanceMethods[F] };
 
     /** The original object passed to the schema constructor */
     obj: SchemaDefinition<SchemaDefinitionType<DocType>>;
@@ -1328,7 +1331,7 @@ declare module 'mongoose' {
     /** Lists all paths and their type in the schema. */
     paths: {
       [key: string]: SchemaType;
-    }
+    };
 
     /** Returns the pathType of `path` for this schema. */
     pathType(path: string): string;
@@ -1337,37 +1340,37 @@ declare module 'mongoose' {
     plugin(fn: (schema: Schema<DocType>, opts?: any) => void, opts?: any): this;
 
     /** Defines a post hook for the model. */
-    post<T = HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T>): this;
-    post<T = HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
-    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: PostMiddlewareFunction<T>): this;
-    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
-    post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, fn: PostMiddlewareFunction<T, Array<any>>): this;
-    post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, Array<any>>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
+    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: PostMiddlewareFunction<T>): this;
+    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
+    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PostMiddlewareFunction<T, Array<any>>): this;
+    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, Array<any>>): this;
     post<T = M>(method: 'insertMany' | RegExp, fn: PostMiddlewareFunction<T>): this;
     post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T>): this;
 
-    post<T = HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
-    post<T = HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
-    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
-    post<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
-    post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
-    post<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
+    post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
     post<T = M>(method: 'insertMany' | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
     post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
 
     /** Defines a pre hook for the model. */
-    pre<T = HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
-    pre<T = HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
-    pre<T = HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
-    pre<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: PreMiddlewareFunction<T>): this;
-    pre<T extends Query<any, any> = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
-    pre<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, fn: PreMiddlewareFunction<T>): this;
-    pre<T extends Aggregate<any> = Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
+    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
+    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
+    pre<T extends Query<any, any>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
+    pre<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, fn: PreMiddlewareFunction<T>): this;
+    pre<T extends Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | string | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
+    pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PreMiddlewareFunction<T>): this;
+    pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = M>(method: 'insertMany' | RegExp, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
     pre<T = M>(method: 'insertMany' | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
 
     /** Object of currently defined query helpers on this schema. */
-    query: { [name: string]: (this: QueryWithHelpers<any, DocType, ExtractQueryHelpers<M>>, ...args: any[]) => any };
+    query: TQueryHelpers;
 
     /** Adds a method call to the queue. */
     queue(name: string, args: any[]): this;
@@ -1624,7 +1627,7 @@ declare module 'mongoose' {
      * The default value for this path. If a function, Mongoose executes the function
      * and uses the return value as the default.
      */
-    default?: T | ((this: any, doc: any) => T);
+    default?: T | ((this: any, doc: any) => Partial<T>);
 
     /**
      * The model that `populate()` should use if populating this path.
@@ -1685,7 +1688,7 @@ declare module 'mongoose' {
     enum?: Array<string | number | null> | ReadonlyArray<string | number | null> | { values: Array<string | number | null> | ReadonlyArray<string | number | null>, message?: string } | { [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
+    subtype?: number;
 
     /** The minimum value allowed for this path. Only allowed for numbers and dates. */
     min?: number | NativeDate | [number, string] | [NativeDate, string] | readonly [number, string] | readonly [NativeDate, string];
@@ -2094,7 +2097,7 @@ declare module 'mongoose' {
       _id: this;
     }
 
-    class Subdocument extends Document {
+    class Subdocument<IdType = any> extends Document<IdType> {
       $isSingleNested: true;
 
       /** Returns the top level document of this sub-document. */
@@ -2112,6 +2115,8 @@ declare module 'mongoose' {
 
   type QueryWithHelpers<ResultType, DocType, THelpers = {}, RawDocType = DocType> = Query<ResultType, DocType, THelpers, RawDocType> & THelpers;
 
+  type UnpackedIntersection<T, U> = T extends (infer V)[] ? (V & U)[] : T & U;
+
   class Query<ResultType, DocType, THelpers = {}, RawDocType = DocType> {
     _mongooseOptions: MongooseQueryOptions;
 
@@ -2315,7 +2320,7 @@ declare module 'mongoose' {
     j(val: boolean | null): this;
 
     /** Sets the lean option. */
-    lean<LeanResultType = RawDocType extends Document ? LeanDocumentOrArray<ResultType> : LeanDocumentOrArrayWithRawType<ResultType, RawDocType>>(val?: boolean | any): QueryWithHelpers<LeanResultType, DocType, THelpers, RawDocType>;
+    lean<LeanResultType = RawDocType extends Document ? LeanDocumentOrArray<ResultType> : LeanDocumentOrArrayWithRawType<ResultType, Require_id<RawDocType>>>(val?: boolean | any): QueryWithHelpers<LeanResultType, DocType, THelpers, RawDocType>;
 
     /** Specifies the maximum number of documents the query will return. */
     limit(val: number): this;
@@ -2332,7 +2337,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: ResultType) => MappedType): QueryWithHelpers<MappedType, DocType, THelpers, RawDocType>;
+    transform<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;
@@ -2394,11 +2399,11 @@ declare module 'mongoose' {
     polygon(path: string, ...coordinatePairs: number[][]): this;
 
     /** Specifies paths which should be populated with other documents. */
-    populate<Paths = {}>(path: string | any, select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<ResultType & Paths, DocType, THelpers, RawDocType>;
-    populate<Paths = {}>(options: PopulateOptions | Array<PopulateOptions>): QueryWithHelpers<ResultType & Paths, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(path: string | any, select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(options: PopulateOptions | Array<PopulateOptions>): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
 
     /** Get/set the current projection (AKA fields). Pass `null` to remove the current projection. */
-    projection(fields?: any | null): any;
+    projection(fields?: any | null): this;
 
     /** Determines the MongoDB nodes from which to read. */
     read(pref: string | mongodb.ReadPreferenceMode, tags?: any[]): this;
@@ -2674,7 +2679,9 @@ declare module 'mongoose' {
     };
 
   export type FlattenMaps<T> = {
-    [K in keyof T]: T[K] extends Map<any, any> ? AnyObject : FlattenMaps<T[K]>;
+    [K in keyof T]: T[K] extends Map<any, any>
+      ? AnyObject : T[K] extends TreatAsPrimitives
+      ? T[K] : FlattenMaps<T[K]>;
   };
 
   type actualPrimitives = string | boolean | number | bigint | symbol | null | undefined;
@@ -2704,10 +2711,6 @@ declare module 'mongoose' {
   export type SchemaDefinitionType<T> = T extends Document ? Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>> : T;
   export type LeanDocument<T> = Omit<_LeanDocument<T>, Exclude<keyof Document, '_id' | 'id' | '__v'> | '$isSingleNested'>;
 
-  type DeepPartial<T> = {
-    [K in keyof T]?: DeepPartial<T[K]>;
-  }
-
   export type LeanDocumentOrArray<T> = 0 extends (1 & T) ? T :
     T extends unknown[] ? LeanDocument<T[number]>[] :
     T extends Document ? LeanDocument<T> :
@@ -2762,6 +2765,13 @@ declare module 'mongoose' {
   }
 
   class Aggregate<R> {
+    /**
+     * Returns an asyncIterator for use with [`for/await/of` loops](https://thecodebarbarian.com/getting-started-with-async-iterators-in-node-js
+     * You do not need to call this function explicitly, the JavaScript runtime
+     * will call it for you.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<Unpacked<R>>;
+
     /**
      * Sets an option on this aggregation. This function will be deprecated in a
      * future release. */
@@ -3016,12 +3026,11 @@ declare module 'mongoose' {
 
     export interface Facet {
       /** [`$facet` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/facet/) */
-      $facet: Record<
-        string,
-        Exclude<PipelineStage, PipelineStage.CollStats | PipelineStage.Facet | PipelineStage.GeoNear | PipelineStage.IndexStats | PipelineStage.Out | PipelineStage.Merge | PipelineStage.PlanCacheStats>[]
-      >
+      $facet: Record<string, FacetPipelineStage[]>
     }
 
+    export type FacetPipelineStage = Exclude<PipelineStage, PipelineStage.CollStats | PipelineStage.Facet | PipelineStage.GeoNear | PipelineStage.IndexStats | PipelineStage.Out | PipelineStage.Merge | PipelineStage.PlanCacheStats>
+
     export interface GeoNear {
       /** [`$geoNear` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/geoNear/) */
       $geoNear: {
@@ -3054,10 +3063,7 @@ declare module 'mongoose' {
 
     export interface Group {
       /** [`$group` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/group) */
-      $group: {
-        _id: any
-        [key: string]: { [op in AccumulatorOperator]?: any }
-      }
+      $group: { _id: any } | { [key: string]: { [op in AccumulatorOperator]?: any } }
     }
 
     export interface IndexStats {
@@ -3098,7 +3104,7 @@ declare module 'mongoose' {
         into: string | { db: string; coll: string }
         on?: string | string[]
         let?: Record<string, any>
-        whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | 'pipeline'
+        whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | Extract<PipelineStage, PipelineStage.AddFields | PipelineStage.Set | PipelineStage.Project | PipelineStage.Unset | PipelineStage.ReplaceRoot | PipelineStage.ReplaceWith>[]
         whenNotMatched?: 'insert' | 'discard' | 'fail'
       }
     }
@@ -3115,7 +3121,7 @@ declare module 'mongoose' {
 
     export interface Project {
       /** [`$project` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/project/) */
-      $project: { _id?: 0 | false; [field: string]: any }
+      $project: { [field: string]: any }
     }
 
     export interface Redact {

package/lib/aggregate.js

@@ -892,7 +892,7 @@ Aggregate.prototype.collation = function(collation) {
  *     const res = await Model.aggregate().facet({
  *       books: [{ groupBy: '$author' }],
  *       price: [{ $bucketAuto: { groupBy: '$price', buckets: 2 } }]
- *    });
+ *     });
  *
  *     // Output: { books: [...], price: [{...}, {...}] }
  *

package/lib/connection.js

@@ -43,10 +43,10 @@ const noPasswordAuthMechanisms = [
  * @inherits NodeJS EventEmitter http://nodejs.org/api/events.html#events_class_events_eventemitter
  * @event `connecting`: Emitted when `connection.openUri()` is executed on this connection.
  * @event `connected`: Emitted when this connection successfully connects to the db. May be emitted _multiple_ times in `reconnected` scenarios.
- * @event `open`: Emitted after we `connected` and `onOpen` is executed on all of this connections models.
+ * @event `open`: Emitted after we `connected` and `onOpen` is executed on all of this connection's models.
  * @event `disconnecting`: Emitted when `connection.close()` was executed.
  * @event `disconnected`: Emitted after getting disconnected from the db.
- * @event `close`: Emitted after we `disconnected` and `onClose` executed on all of this connections models.
+ * @event `close`: Emitted after we `disconnected` and `onClose` executed on all of this connection's models.
  * @event `reconnected`: Emitted after we `connected` and subsequently `disconnected`, followed by successfully another successful connection.
  * @event `error`: Emitted when an error occurs on this connection.
  * @event `fullsetup`: Emitted after the driver has connected to primary and all secondaries if specified in the connection string.
@@ -1082,8 +1082,12 @@ Connection.prototype.model = function(name, schema, collection, options) {
     schema = false;
   }
 
-  if (utils.isObject(schema) && !(schema instanceof this.base.Schema)) {
-    schema = new Schema(schema);
+  if (utils.isObject(schema)) {
+    if (!schema.instanceOfSchema) {
+      schema = new Schema(schema);
+    } else if (!(schema instanceof this.base.Schema)) {
+      schema = schema._clone(this.base.Schema);
+    }
   }
   if (schema && !schema.instanceOfSchema) {
     throw new Error('The 2nd parameter to `mongoose.model()` should be a ' +
@@ -1359,7 +1363,7 @@ Connection.prototype.setClient = function setClient(client) {
   if (!(client instanceof mongodb.MongoClient)) {
     throw new MongooseError('Must call `setClient()` with an instance of MongoClient');
   }
-  if (this.client != null || this.readyState !== STATES.disconnected) {
+  if (this.readyState !== STATES.disconnected) {
     throw new MongooseError('Cannot call `setClient()` on a connection that is already connected.');
   }
   if (client.topology == null) {

package/lib/cursor/QueryCursor.js

@@ -467,7 +467,7 @@ function _nextDoc(ctx, doc, pop, callback) {
     });
   }
 
-  _create(ctx, doc, pop, (err, doc) => {
+  ctx.query._completeOne(doc, null, (err, doc) => {
     if (err != null) {
       return callback(err);
     }
@@ -496,22 +496,4 @@ function _waitForCursor(ctx, cb) {
   });
 }
 
-/*!
- * Convert a raw doc into a full mongoose doc.
- */
-
-function _create(ctx, doc, populatedIds, cb) {
-  const instance = helpers.createModel(ctx.query.model, doc, ctx.query._fields);
-  const opts = populatedIds ?
-    { populated: populatedIds } :
-    undefined;
-
-  instance.$init(doc, opts, function(err) {
-    if (err) {
-      return cb(err);
-    }
-    cb(null, instance);
-  });
-}
-
 module.exports = QueryCursor;

package/lib/document.js

@@ -91,12 +91,14 @@ function Document(obj, fields, skipId, options) {
   }
 
   this.$__ = new InternalCache;
-  this.$__.emitter = new EventEmitter();
   this.$isNew = 'isNew' in options ? options.isNew : true;
 
   if ('priorDoc' in options) {
     this.$__.priorDoc = options.priorDoc;
   }
+  if (skipId) {
+    this.$__.skipId = skipId;
+  }
 
   if (obj != null && typeof obj !== 'object') {
     throw new ObjectParameterError(obj, 'obj', 'Document');
@@ -125,14 +127,15 @@ function Document(obj, fields, skipId, options) {
     this.$__.activePaths.require(path);
   }
 
-  this.$__.emitter.setMaxListeners(0);
-
   let exclude = null;
 
   // determine if this doc is a result of a query with
   // excluded fields
   if (utils.isPOJO(fields)) {
     exclude = isExclusive(fields);
+
+    this.$__.fields = fields;
+    this.$__.exclude = exclude;
   }
 
   const hasIncludedChildren = exclude === false && fields ?
@@ -145,7 +148,7 @@ function Document(obj, fields, skipId, options) {
     // By default, defaults get applied **before** setting initial values
     // Re: gh-6155
     if (defaults) {
-      $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, true, {
+      $__applyDefaults(this, fields, exclude, hasIncludedChildren, true, {
         isNew: this.$isNew
       });
     }
@@ -167,13 +170,11 @@ function Document(obj, fields, skipId, options) {
   // see the full doc rather than an empty one, unless they opt out.
   // Re: gh-3781, gh-6155
   if (options.willInit && defaults) {
-    EventEmitter.prototype.once.call(this, 'init', () => {
-      $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, false, options.skipDefaults, {
-        isNew: this.$isNew
-      });
-    });
+    if (options.skipDefaults) {
+      this.$__.skipDefaults = options.skipDefaults;
+    }
   } else if (defaults) {
-    $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, false, options.skipDefaults, {
+    $__applyDefaults(this, fields, exclude, hasIncludedChildren, false, options.skipDefaults, {
       isNew: this.$isNew
     });
   }
@@ -222,6 +223,15 @@ utils.each(
     'removeAllListeners', 'addListener'],
   function(emitterFn) {
     Document.prototype[emitterFn] = function() {
+      // Delay creating emitter until necessary because emitters take up a lot of memory,
+      // especially for subdocuments.
+      if (!this.$__.emitter) {
+        if (emitterFn === 'emit') {
+          return;
+        }
+        this.$__.emitter = new EventEmitter();
+        this.$__.emitter.setMaxListeners(0);
+      }
       return this.$__.emitter[emitterFn].apply(this.$__.emitter, arguments);
     };
     Document.prototype[`$${emitterFn}`] = Document.prototype[emitterFn];
@@ -416,12 +426,18 @@ function $__hasIncludedChildren(fields) {
   const keys = Object.keys(fields);
 
   for (const key of keys) {
+    if (key.indexOf('.') === -1) {
+      hasIncludedChildren[key] = 1;
+      continue;
+    }
     const parts = key.split('.');
-    const c = [];
+    let c = parts[0];
 
-    for (const part of parts) {
-      c.push(part);
-      hasIncludedChildren[c.join('.')] = 1;
+    for (let i = 0; i < parts.length; ++i) {
+      hasIncludedChildren[c] = 1;
+      if (i + 1 < parts.length) {
+        c = c + '.' + parts[i + 1];
+      }
     }
   }
 
@@ -432,7 +448,7 @@ function $__hasIncludedChildren(fields) {
  * ignore
  */
 
-function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren, isBeforeSetters, pathsToSkip) {
+function $__applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSetters, pathsToSkip) {
   const paths = Object.keys(doc.$__schema.paths);
   const plen = paths.length;
 
@@ -441,7 +457,7 @@ function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren, isB
     let curPath = '';
     const p = paths[i];
 
-    if (p === '_id' && skipId) {
+    if (p === '_id' && doc.$__.skipId) {
       continue;
     }
 
@@ -720,13 +736,8 @@ Document.prototype.$init = function() {
   return this.constructor.prototype.init.apply(this, arguments);
 };
 
-/*!
- * ignore
- */
-
 Document.prototype.$__init = function(doc, opts) {
   this.$isNew = false;
-  this.$init = true;
   opts = opts || {};
 
   // handle docs with populated paths
@@ -761,6 +772,12 @@ Document.prototype.$__init = function(doc, opts) {
   this.constructor.emit('init', this);
 
   this.$__._id = this._id;
+
+  const hasIncludedChildren = this.$__.exclude === false && this.$__.fields ?
+    $__hasIncludedChildren(this.$__.fields) :
+    {};
+  $__applyDefaults(this, this.$__.fields, this.$__.exclude, hasIncludedChildren, false, this.$__.skipDefaults);
+
   return this;
 };
 
@@ -820,8 +837,7 @@ function init(self, obj, doc, opts, prefix) {
       if (obj[i] === null) {
         doc[i] = schema._castNullish(null);
       } else if (obj[i] !== undefined) {
-        const intCache = obj[i].$__ || {};
-        const wasPopulated = intCache.wasPopulated || null;
+        const wasPopulated = obj[i].$__ == null ? null : obj[i].$__.wasPopulated;
 
         if (schema && !wasPopulated) {
           try {
@@ -988,10 +1004,13 @@ Document.prototype.$session = function $session(session) {
       'called `endSession()` on the session you are passing to `$session()`.');
   }
 
-  this.$__.session = session;
+  if (session == null && this.$__.session == null) {
+    return;
+  }
 
+  this.$__.session = session;
 
-  if (!this.$__.isSubDocument) {
+  if (!this.$isSubdocument) {
     const subdocs = this.$getAllSubdocs();
     for (const child of subdocs) {
       child.$session(session);
@@ -1143,13 +1162,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
         }
 
         if (pathtype === 'real' || pathtype === 'virtual') {
-          // Check for setting single embedded schema to document (gh-3535)
-          let p = path[key];
-          if (this.$__schema.paths[pathName] &&
-              this.$__schema.paths[pathName].$isSingleNested &&
-              path[key] instanceof Document) {
-            p = p.toObject({ virtuals: false, transform: false });
-          }
+          const p = path[key];
           this.$set(prefix + key, p, constructing, options);
         } else if (pathtype === 'nested' && path[key] instanceof Document) {
           this.$set(prefix + key,
@@ -1410,7 +1423,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       didPopulate = true;
     }
 
-    if (this.$__schema.singleNestedPaths[path] == null) {
+    if (this.$__schema.singleNestedPaths[path] == null && (!refMatches || !schema.$isSingleNested || !val.$__)) {
       // If this path is underneath a single nested schema, we'll call the setter
       // later in `$__set()` because we don't take `_doc` when we iterate through
       // a single nested doc. That's to make sure we get the correct context.
@@ -1468,9 +1481,9 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   if (shouldSet) {
-    const doc = this.$__.isSubDocument ? this.ownerDocument() : this;
+    const doc = this.$isSubdocument ? this.ownerDocument() : this;
     const savedState = doc.$__.savedState;
-    const savedStatePath = this.$__.isSubDocument ? this.$__.fullPath + '.' + path : path;
+    const savedStatePath = this.$isSubdocument ? this.$__.fullPath + '.' + path : path;
     if (savedState != null) {
       const firstDot = savedStatePath.indexOf('.');
       const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
@@ -1844,7 +1857,7 @@ Document.prototype.$__path = function(path) {
 
 Document.prototype.markModified = function(path, scope) {
   this.$__.activePaths.modify(path);
-  if (scope != null && !this.$__.isSubDocument) {
+  if (scope != null && !this.$isSubdocument) {
     this.$__.pathsToScopes = this.$__pathsToScopes || {};
     this.$__.pathsToScopes[path] = scope;
   }
@@ -2061,11 +2074,15 @@ Document.prototype[documentModifiedPaths] = Document.prototype.modifiedPaths;
 
 Document.prototype.isModified = function(paths, modifiedPaths) {
   if (paths) {
+    const directModifiedPaths = Object.keys(this.$__.activePaths.states.modify);
+    if (directModifiedPaths.length === 0) {
+      return false;
+    }
+
     if (!Array.isArray(paths)) {
-      paths = paths.split(' ');
+      paths = paths.indexOf(' ') === -1 ? [paths] : paths.split(' ');
     }
     const modified = modifiedPaths || this[documentModifiedPaths]();
-    const directModifiedPaths = Object.keys(this.$__.activePaths.states.modify);
     const isModifiedChild = paths.some(function(path) {
       return !!~modified.indexOf(path);
     });
@@ -2222,7 +2239,9 @@ Document.prototype.isSelected = function isSelected(path) {
   if (this.$__.selected == null) {
     return true;
   }
-
+  if (!path) {
+    return false;
+  }
   if (path === '_id') {
     return this.$__.selected._id !== 0;
   }
@@ -2372,7 +2391,7 @@ Document.prototype.validate = function(pathsToValidate, options, callback) {
   let parallelValidate;
   this.$op = 'validate';
 
-  if (this.$__.isSubDocument != null) {
+  if (this.$isSubdocument != null) {
     // Skip parallel validate check for subdocuments
   } else if (this.$__.validating) {
     parallelValidate = new ParallelValidateError(this, {
@@ -3119,7 +3138,7 @@ Document.prototype.$__reset = function reset() {
       doc.$__reset();
       if (doc.$parent() === _this) {
         _this.$__.activePaths.init(doc.$basePath);
-      } else if (doc.$parent() != null && doc.$parent().$__.isSubDocument) {
+      } else if (doc.$parent() != null && doc.$parent().$isSubdocument) {
         // If map path underneath subdocument, may end up with a case where
         // map path is modified but parent still needs to be reset. See gh-10295
         doc.$parent().$__reset();
@@ -3971,7 +3990,7 @@ Document.prototype.ownerDocument = function() {
  */
 
 Document.prototype.parent = function() {
-  if (this.$__.isSubDocument || this.$__.wasPopulated) {
+  if (this.$isSubdocument || this.$__.wasPopulated) {
     return this.$__.parent;
   }
   return this;

package/lib/helpers/common.js

@@ -19,7 +19,7 @@ exports.modifiedPaths = modifiedPaths;
 function flatten(update, path, options, schema) {
   let keys;
   if (update && isMongooseObject(update) && !Buffer.isBuffer(update)) {
-    keys = Object.keys(update.toObject({ transform: false, virtuals: false }));
+    keys = Object.keys(update.toObject({ transform: false, virtuals: false }) || {});
   } else {
     keys = Object.keys(update || {});
   }

package/lib/helpers/document/cleanModifiedSubpaths.js

@@ -22,6 +22,12 @@ module.exports = function cleanModifiedSubpaths(doc, path, options) {
     if (modifiedPath.startsWith(path + '.')) {
       delete doc.$__.activePaths.states.modify[modifiedPath];
       ++deleted;
+
+      if (doc.$isSubdocument) {
+        const owner = doc.ownerDocument();
+        const fullPath = doc.$__fullPath(modifiedPath);
+        delete owner.$__.activePaths.states.modify[fullPath];
+      }
     }
   }
   return deleted;