mongoose 6.0.13 → 6.1.1

package/index.d.ts

@@ -659,10 +659,10 @@ declare module 'mongoose' {
     $parent(): Document | undefined;
 
     /** Populates document references. */
-    populate<Paths>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<this & Paths>;
-    populate<Paths>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<this & Paths>): void;
-    populate<Paths>(path: string, names: string): Promise<this & Paths>;
-    populate<Paths>(path: string, names: string, callback: Callback<this & Paths>): void;
+    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<this & Paths>;
+    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<this & Paths>): void;
+    populate<Paths = {}>(path: string, names: string): Promise<this & Paths>;
+    populate<Paths = {}>(path: string, names: string, callback: Callback<this & Paths>): void;
 
     /** Gets _id(s) used during population of the given `path`. If the path was not populated, returns `undefined`. */
     populated(path: string): any;
@@ -747,9 +747,8 @@ declare module 'mongoose' {
   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>;
 
-    aggregate<R = any>(pipeline?: any[], options?: Record<string, unknown>): Aggregate<Array<R>>;
-    aggregate<R = any>(pipeline: any[], cb: Function): Promise<Array<R>>;
-    aggregate<R = any>(pipeline: any[], options: Record<string, unknown>, cb: Function): Promise<Array<R>>;
+    aggregate<R = any>(pipeline?: PipelineStage[], options?: mongodb.AggregateOptions, callback?: Callback<R[]>): Aggregate<Array<R>>;
+    aggregate<R = any>(pipeline: PipelineStage[], cb: Function): Aggregate<Array<R>>;
 
     /** Base Mongoose instance the model uses. */
     base: typeof mongoose;
@@ -1001,7 +1000,7 @@ declare module 'mongoose' {
     replaceOne(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<any, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
 
     /** Schema the model uses. */
-    schema: Schema;
+    schema: Schema<T>;
 
     /**
      * @deprecated use `updateOne` or `updateMany` instead.
@@ -1248,7 +1247,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 = {}> extends events.EventEmitter {
+  class Schema<DocType = any, M = Model<DocType, any, any, any>, TInstanceMethods = any> extends events.EventEmitter {
     /**
      * Create a new schema
      */
@@ -1302,7 +1301,7 @@ declare module 'mongoose' {
     methods: { [name: string]: (this: HydratedDocument<DocType, TInstanceMethods, ExtractVirtuals<M>>, ...args: any[]) => any };
 
     /** The original object passed to the schema constructor */
-    obj: any;
+    obj: SchemaDefinition<SchemaDefinitionType<DocType>>;
 
     /** Gets/sets schema paths. */
     path<ResultType extends SchemaType = SchemaType>(path: string): ResultType;
@@ -1399,7 +1398,8 @@ declare module 'mongoose' {
     SchemaTypeOptions<T extends undefined ? any : T>[] |
     Function[] |
     SchemaDefinition<T> |
-    SchemaDefinition<T>[];
+    SchemaDefinition<T>[] |
+    typeof SchemaTypes.Mixed;
 
   type SchemaDefinition<T = undefined> = T extends undefined
     ? { [path: string]: SchemaDefinitionProperty; }
@@ -1436,6 +1436,10 @@ declare module 'mongoose' {
     capped?: boolean | number | { size?: number; max?: number; autoIndexId?: boolean; };
     /** Sets a default collation for every query and aggregation. */
     collation?: mongodb.CollationOptions;
+
+    /** The timeseries option to use when creating the model's collection. */
+    timeseries?: mongodb.TimeSeriesCollectionOptions;
+
     /**
      * Mongoose by default produces a collection name by passing the model name to the utils.toCollectionName
      * method. This method pluralizes the name. Set this option if you need a different name for your collection.
@@ -1567,6 +1571,7 @@ declare module 'mongoose' {
       T extends string | number | boolean | NativeDate | Function ? SchemaDefinitionWithBuiltInClass<T> :
       T extends Schema<any, any, any> ? T :
       T extends Map<any, any> ? SchemaDefinition<typeof Map> :
+      T extends Buffer ? SchemaDefinition<typeof Buffer> :
       T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>>>) :
       T extends string[] ? AnyArray<SchemaDefinitionWithBuiltInClass<string>> | AnyArray<SchemaTypeOptions<string>> :
       T extends number[] ? AnyArray<SchemaDefinitionWithBuiltInClass<number>> | AnyArray<SchemaTypeOptions<number>> :
@@ -2040,7 +2045,7 @@ declare module 'mongoose' {
 
     class Decimal128 extends mongodb.Decimal128 { }
 
-    class DocumentArray<T extends Document> extends Types.Array<T> {
+    class DocumentArray<T> extends Types.Array<T> {
       /** DocumentArray constructor */
       constructor(values: any[]);
 
@@ -2364,8 +2369,8 @@ 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<ResultType & Paths, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(options: PopulateOptions | Array<PopulateOptions>): QueryWithHelpers<ResultType & Paths, DocType, THelpers, RawDocType>;
 
     /** Get/set the current projection (AKA fields). Pass `null` to remove the current projection. */
     projection(fields?: any | null): any;
@@ -2645,7 +2650,7 @@ declare module 'mongoose' {
     [K in keyof T]: __UpdateDefProperty<T[K]>;
   };
 
-  export type UpdateQuery<T> = (_UpdateQuery<_UpdateQueryDef<T>> & MatchKeysAndValues<_UpdateQueryDef<LeanDocument<T>>>);
+  export type UpdateQuery<T> = (_UpdateQuery<_UpdateQueryDef<T>> & MatchKeysAndValues<_UpdateQueryDef<DeepPartial<T>>>);
 
   export type DocumentDefinition<T> = {
     [K in keyof Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>>]:
@@ -2687,6 +2692,10 @@ 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> :
@@ -2750,7 +2759,7 @@ declare module 'mongoose' {
      * Appends a new $addFields operator to this aggregate pipeline.
      * Requires MongoDB v3.4+ to work
      */
-    addFields(arg: any): this;
+    addFields(arg: PipelineStage.AddFields['$addFields']): this;
 
     /** Sets the allowDiskUse option for the aggregation query (ignored for < 2.6.0) */
     allowDiskUse(value: boolean): this;
@@ -2769,7 +2778,7 @@ declare module 'mongoose' {
     collation(options: mongodb.CollationOptions): this;
 
     /** Appends a new $count operator to this aggregate pipeline. */
-    count(countName: string): this;
+    count(countName: PipelineStage.Count['$count']): this;
 
     /**
      * Sets the cursor option for the aggregation query (ignored for < 2.6.0).
@@ -2783,13 +2792,13 @@ declare module 'mongoose' {
     explain(callback?: Callback): Promise<any>;
 
     /** Combines multiple aggregation pipelines. */
-    facet(options: any): this;
+    facet(options: PipelineStage.Facet['$facet']): this;
 
     /** Appends new custom $graphLookup operator(s) to this aggregate pipeline, performing a recursive search on a collection. */
-    graphLookup(options: any): this;
+    graphLookup(options: PipelineStage.GraphLookup['$graphLookup']): this;
 
     /** Appends new custom $group operator to this aggregate pipeline. */
-    group(arg: any): this;
+    group(arg: PipelineStage.Group['$group']): this;
 
     /** Sets the hint option for the aggregation query (ignored for < 3.6.0) */
     hint(value: Record<string, unknown> | string): this;
@@ -2798,16 +2807,16 @@ declare module 'mongoose' {
      * Appends a new $limit operator to this aggregate pipeline.
      * @param num maximum number of records to pass to the next stage
      */
-    limit(num: number): this;
+    limit(num: PipelineStage.Limit['$limit']): this;
 
     /** Appends new custom $lookup operator to this aggregate pipeline. */
-    lookup(options: any): this;
+    lookup(options: PipelineStage.Lookup['$lookup']): this;
 
     /**
      * Appends a new custom $match operator to this aggregate pipeline.
      * @param arg $match operator contents
      */
-    match(arg: any): this;
+    match(arg: PipelineStage.Match['$match']): this;
 
     /**
      * Binds this aggregate to a model.
@@ -2825,7 +2834,7 @@ declare module 'mongoose' {
     pipeline(): any[];
 
     /** Appends a new $project operator to this aggregate pipeline. */
-    project(arg: string | Object): this;
+    project(arg: PipelineStage.Project['$project']): this;
 
     /** Sets the readPreference option for the aggregation query. */
     read(pref: string | mongodb.ReadPreferenceMode, tags?: any[]): this;
@@ -2837,13 +2846,13 @@ declare module 'mongoose' {
     redact(expression: any, thenExpr: string | any, elseExpr: string | any): this;
 
     /** Appends a new $replaceRoot operator to this aggregate pipeline. */
-    replaceRoot(newRoot: object | string): this;
+    replaceRoot(newRoot: PipelineStage.ReplaceRoot['$replaceRoot'] | string): this;
 
     /**
      * Helper for [Atlas Text Search](https://docs.atlas.mongodb.com/reference/atlas-search/tutorial/)'s
      * `$search` stage.
      */
-    search(options: any): this;
+    search(options: PipelineStage.Search['$search']): this;
 
     /** Lets you set arbitrary options, for middleware or plugins. */
     option(value: Record<string, unknown>): this;
@@ -2861,7 +2870,7 @@ declare module 'mongoose' {
     skip(num: number): this;
 
     /** Appends a new $sort operator to this aggregate pipeline. */
-    sort(arg: any): this;
+    sort(arg: PipelineStage.Sort['$sort']): this;
 
     /** Provides promise for aggregate. */
     then: Promise<R>['then'];
@@ -2872,8 +2881,11 @@ declare module 'mongoose' {
      */
     sortByCount(arg: string | any): this;
 
+    /** Appends new $unionWith operator to this aggregate pipeline. */
+    unionWith(options: any): this;
+
     /** Appends new custom $unwind operator(s) to this aggregate pipeline. */
-    unwind(...args: any[]): this;
+    unwind(...args: PipelineStage.Unwind['$unwind'][]): this;
   }
 
   class AggregationCursor extends stream.Readable {
@@ -2913,6 +2925,276 @@ declare module 'mongoose' {
     next(callback: Callback): void;
   }
 
+  /**
+   * [Stages reference](https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline/#aggregation-pipeline-stages)
+   */
+  export type PipelineStage =
+    | PipelineStage.AddFields
+    | PipelineStage.Bucket
+    | PipelineStage.BucketAuto
+    | PipelineStage.CollStats
+    | PipelineStage.Count
+    | PipelineStage.Facet
+    | PipelineStage.GeoNear
+    | PipelineStage.GraphLookup
+    | PipelineStage.Group
+    | PipelineStage.IndexStats
+    | PipelineStage.Limit
+    | PipelineStage.ListSessions
+    | PipelineStage.Lookup
+    | PipelineStage.Match
+    | PipelineStage.Merge
+    | PipelineStage.Out
+    | PipelineStage.PlanCacheStats
+    | PipelineStage.Project
+    | PipelineStage.Redact
+    | PipelineStage.ReplaceRoot
+    | PipelineStage.ReplaceWith
+    | PipelineStage.Sample
+    | PipelineStage.Search
+    | PipelineStage.Set
+    | PipelineStage.SetWindowFields
+    | PipelineStage.Skip
+    | PipelineStage.Sort
+    | PipelineStage.SortByCount
+    | PipelineStage.UnionWith
+    | PipelineStage.Unset
+    | PipelineStage.Unwind
+
+  export namespace PipelineStage {
+    export interface AddFields {
+      /** [`$addFields` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/addFields/) */
+      $addFields: Record<string, any>
+    }
+
+    export interface Bucket {
+      /** [`$bucket` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/bucket/) */
+      $bucket: {
+        groupBy: any
+        boundaries: any[]
+        default?: any
+        output?: Record<string, { [op in AccumulatorOperator]?: any }>
+      }
+    }
+
+    export interface BucketAuto {
+      /** [`$bucketAuto` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/bucketAuto/) */
+      $bucketAuto: {
+        groupBy: any
+        buckets: number
+        output?: Record<string, { [op in AccumulatorOperator]?: any }>
+        granularity?: 'R5' | 'R10' | 'R20' | 'R40' | 'R80' | '1-2-5' | 'E6' | 'E12' | 'E24' | 'E48' | 'E96' | 'E192' | 'POWERSOF2'
+      }
+    }
+
+    export interface CollStats {
+      /** [`$collStats` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/collStats/) */
+      $collStats: {
+        latencyStats?: { histograms?: boolean }
+        storageStats?: { scale?: number }
+        count?: {}
+        queryExecStats?: {}
+      }
+    }
+
+    export interface Count {
+      /** [`$count` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/count/) */
+      $count: string
+    }
+
+    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>[]
+      >
+    }
+
+    export interface GeoNear {
+      /** [`$geoNear` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/geoNear/) */
+      $geoNear: {
+        near: { type: 'Point'; coordinates: [number, number] } | [number, number]
+        distanceField: string
+        distanceMultiplier?: number
+        includeLocs?: string
+        key?: string
+        maxDistance?: number
+        minDistance?: number
+        query?: AnyObject
+        spherical?: boolean
+        uniqueDocs?: boolean
+      }
+    }
+
+    export interface GraphLookup {
+      /** [`$graphLookup` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/graphLookup/) */
+      $graphLookup: {
+        from: string
+        startWith: any
+        connectFromField: string
+        connectToField: string
+        as: string
+        maxDepth?: number
+        depthField?: string
+        restrictSearchWithMatch?: AnyObject
+      }
+    }
+
+    export interface Group {
+      /** [`$group` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/group) */
+      $group: {
+        _id: any
+        [key: string]: { [op in AccumulatorOperator]?: any }
+      }
+    }
+
+    export interface IndexStats {
+      /** [`$indexStats` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/indexStats/) */
+      $indexStats: {}
+    }
+
+    export interface Limit {
+      /** [`$limit` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/limit/) */
+      $limit: number
+    }
+
+    export interface ListSessions {
+      /** [`$listSessions` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/listSessions/) */
+      $listSessions: { users?: { user: string; db: string }[] } | { allUsers?: true }
+    }
+
+    export interface Lookup {
+      /** [`$lookup` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/lookup/) */
+      $lookup: {
+        from: string
+        as: string
+        localField?: string
+        foreignField?: string
+        let?: Record<string, any>
+        pipeline?: Exclude<PipelineStage, PipelineStage.Merge | PipelineStage.Out | PipelineStage.Search>[]
+      }
+    }
+
+    export interface Match {
+      /** [`$match` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/match/) */
+      $match: AnyObject
+    }
+
+    export interface Merge {
+      /** [`$merge` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/merge/) */
+      $merge: {
+        into: string | { db: string; coll: string }
+        on?: string | string[]
+        let?: Record<string, any>
+        whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | 'pipeline'
+        whenNotMatched?: 'insert' | 'discard' | 'fail'
+      }
+    }
+
+    export interface Out {
+      /** [`$out` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/out/) */
+      $out: string | { db: string; coll: string }
+    }
+
+    export interface PlanCacheStats {
+      /** [`$planCacheStats` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/planCacheStats/) */
+      $planCacheStats: {}
+    }
+
+    export interface Project {
+      /** [`$project` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/project/) */
+      $project: { _id?: 0 | false; [field: string]: any }
+    }
+
+    export interface Redact {
+      /** [`$redact` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/redact/) */
+      $redact: any
+    }
+
+    export interface ReplaceRoot {
+      /** [`$replaceRoot` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/replaceRoot/) */
+      $replaceRoot: { newRoot: any }
+    }
+
+    export interface ReplaceWith {
+      /** [`$replaceWith` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/replaceWith/) */
+      $replaceWith: any
+    }
+
+    export interface Sample {
+      /** [`$sample` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/sample/) */
+      $sample: { size: number }
+    }
+
+    export interface Search {
+      /** [`$search` reference](https://docs.atlas.mongodb.com/reference/atlas-search/query-syntax/) */
+      $search: {
+        [key: string]: any
+        index?: string
+        highlight?: { path: string; maxCharsToExamine?: number; maxNumPassages?: number }
+      }
+    }
+
+    export interface Set {
+      /** [`$set` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/set/) */
+      $set: Record<string, any>
+    }
+
+    export interface SetWindowFields {
+      /** [`$setWindowFields` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/setWindowFields/) */
+      $setWindowFields: {
+        partitionBy?: any
+        sortBy?: Record<string, 1 | -1>
+        output: Record<
+          string,
+          { [op in WindowOperator]?: any } & {
+            window?: {
+              documents?: [string | number, string | number]
+              range?: [string | number, string | number]
+              unit?: 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'
+            }
+          }
+        >
+      }
+    }
+
+    export interface Skip {
+      /** [`$skip` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/skip/) */
+      $skip: number
+    }
+
+    export interface Sort {
+      /** [`$sort` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/sort/) */
+      $sort: Record<string, 1 | -1 | { $meta: 'textScore' }>
+    }
+
+    export interface SortByCount {
+      /** [`$sortByCount` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/sortByCount/) */
+      $sortByCount: any
+    }
+
+    export interface UnionWith {
+      /** [`$unionWith` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/unionWith/) */
+      $unionWith:
+        | string
+        | { coll: string; pipeline?: Exclude<PipelineStage, PipelineStage.Out | PipelineStage.Merge> }
+    }
+
+    export interface Unset {
+      /** [`$unset` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/unset/) */
+      $unset: string | string[]
+    }
+
+    export interface Unwind {
+      /** [`$unwind` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/unwind/) */
+      $unwind: string | { path: string; includeArrayIndex?: string; preserveNullAndEmptyArrays?: boolean }
+    }
+
+    type AccumulatorOperator = '$accumulator' | '$addToSet' | '$avg' | '$count' | '$first' | '$last' | '$max' | '$mergeObjects' | '$min' | '$push' | '$stdDevPop' | '$stdDevSamp' | '$sum'
+
+    type WindowOperator = '$addToSet' | '$avg' | '$count' | '$covariancePop' | '$covarianceSamp' | '$derivative' | '$expMovingAvg' | '$integral' | '$max' | '$min' | '$push' | '$stdDevSamp' | '$stdDevPop' | '$sum' | '$first' | '$last' | '$shift' | '$denseRank' | '$documentNumber' | '$rank'
+  }
+
   class SchemaType {
     /** SchemaType constructor */
     constructor(path: string, options?: AnyObject, instance?: string);

package/lib/aggregate.js

@@ -593,6 +593,23 @@ Aggregate.prototype.sort = function(arg) {
   return this.append({ $sort: sort });
 };
 
+/**
+ * Appends new $unionWith operator to this aggregate pipeline.
+ *
+ * ####Examples:
+ *
+ *     aggregate.unionWith({ coll: 'users', pipeline: [ { $match: { _id: 1 } } ] });
+ *
+ * @see $unionWith https://docs.mongodb.com/manual/reference/operator/aggregation/unionWith
+ * @param {Object} options to $unionWith query as described in the above link
+ * @return {Aggregate}* @api public
+ */
+
+Aggregate.prototype.unionWith = function(options) {
+  return this.append({ $unionWith: options });
+};
+
+
 /**
  * Sets the readPreference option for the aggregation query.
  *

package/lib/connection.js

@@ -850,10 +850,10 @@ function _setClient(conn, client, options, dbName) {
   if (type === 'Single') {
     client.on('serverDescriptionChanged', ev => {
       const newDescription = ev.newDescription;
-      if (newDescription.type === 'Standalone') {
-        _handleReconnect();
-      } else {
+      if (newDescription.type === 'Unknown') {
         conn.readyState = STATES.disconnected;
+      } else {
+        _handleReconnect();
       }
     });
   } else if (type.startsWith('ReplicaSet')) {
@@ -1082,7 +1082,7 @@ Connection.prototype.model = function(name, schema, collection, options) {
     schema = false;
   }
 
-  if (utils.isObject(schema) && !schema.instanceOfSchema) {
+  if (utils.isObject(schema) && !(schema instanceof this.base.Schema)) {
     schema = new Schema(schema);
   }
   if (schema && !schema.instanceOfSchema) {
@@ -1372,6 +1372,14 @@ Connection.prototype.setClient = function setClient(client) {
   return this;
 };
 
+Connection.prototype.syncIndexes = async function syncIndexes() {
+  const result = {};
+  for (const model in this.models) {
+    result[model] = await this.model(model).syncIndexes();
+  }
+  return result;
+};
+
 /**
  * Switches to a different database using the same connection pool.
  *

package/lib/document.js

@@ -185,7 +185,9 @@ function Document(obj, fields, skipId, options) {
     const keys = Object.keys(this._doc);
 
     keys.forEach(function(key) {
-      if (!(key in schema.tree)) {
+      // Avoid methods, virtuals, existing fields, and `$` keys. The latter is to avoid overwriting
+      // Mongoose internals.
+      if (!(key in schema.tree) && !(key in schema.methods) && !(key in schema.virtuals) && !key.startsWith('$')) {
         defineKey({ prop: key, subprops: null, prototype: _this });
       }
     });
@@ -806,7 +808,8 @@ function init(self, obj, doc, opts, prefix) {
       init(self, obj[i], doc[i], opts, path + '.');
     } else if (!schema) {
       doc[i] = obj[i];
-      if (!strict) {
+      if (!strict && !prefix) {
+        // Set top-level properties that aren't in the schema if strict is false
         self[i] = obj[i];
       }
     } else {
@@ -987,7 +990,8 @@ Document.prototype.$session = function $session(session) {
 
   this.$__.session = session;
 
-  if (!this.ownerDocument) {
+
+  if (!this.$__.isSubDocument) {
     const subdocs = this.$getAllSubdocs();
     for (const child of subdocs) {
       child.$session(session);
@@ -1196,6 +1200,13 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
   if (pathType === 'nested' && val) {
     if (typeof val === 'object' && val != null) {
+      if (val.$__ != null) {
+        val = val.toObject(internalToObjectOptions);
+      }
+      if (val == null) {
+        this.invalidate(path, new MongooseError.CastError('Object', val, path));
+        return this;
+      }
       const hasInitialVal = this.$__.savedState != null && this.$__.savedState.hasOwnProperty(path);
       if (this.$__.savedState != null && !this.$isNew && !this.$__.savedState.hasOwnProperty(path)) {
         const initialVal = this.$__getValue(path);
@@ -1457,9 +1468,9 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   if (shouldSet) {
-    const doc = this.ownerDocument ? this.ownerDocument() : this;
+    const doc = this.$__.isSubDocument ? this.ownerDocument() : this;
     const savedState = doc.$__.savedState;
-    const savedStatePath = this.ownerDocument ? 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);
@@ -1833,7 +1844,7 @@ Document.prototype.$__path = function(path) {
 
 Document.prototype.markModified = function(path, scope) {
   this.$__.activePaths.modify(path);
-  if (scope != null && !this.ownerDocument) {
+  if (scope != null && !this.$__.isSubDocument) {
     this.$__.pathsToScopes = this.$__pathsToScopes || {};
     this.$__.pathsToScopes[path] = scope;
   }
@@ -2361,7 +2372,7 @@ Document.prototype.validate = function(pathsToValidate, options, callback) {
   let parallelValidate;
   this.$op = 'validate';
 
-  if (this.ownerDocument != null) {
+  if (this.$__.isSubDocument != null) {
     // Skip parallel validate check for subdocuments
   } else if (this.$__.validating) {
     parallelValidate = new ParallelValidateError(this, {
@@ -2420,7 +2431,11 @@ function _evaluateRequiredFunctions(doc) {
 
     if (p != null && typeof p.originalRequiredValue === 'function') {
       doc.$__.cachedRequired = doc.$__.cachedRequired || {};
-      doc.$__.cachedRequired[path] = p.originalRequiredValue.call(doc, doc);
+      try {
+        doc.$__.cachedRequired[path] = p.originalRequiredValue.call(doc, doc);
+      } catch (err) {
+        doc.invalidate(path, err);
+      }
     }
   });
 }
@@ -3104,7 +3119,7 @@ Document.prototype.$__reset = function reset() {
       doc.$__reset();
       if (doc.$parent() === _this) {
         _this.$__.activePaths.init(doc.$basePath);
-      } else if (doc.$parent() != null && doc.$parent().ownerDocument) {
+      } 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();
@@ -3939,9 +3954,15 @@ Document.prototype.toJSON = function(options) {
   return this.$toObject(options, true);
 };
 
+
+Document.prototype.ownerDocument = function() {
+  return this;
+};
+
+
 /**
  * If this document is a subdocument or populated document, returns the document's
- * parent. Returns `undefined` otherwise.
+ * parent. Returns the original document if there is no parent.
  *
  * @api public
  * @method parent
@@ -3950,7 +3971,10 @@ Document.prototype.toJSON = function(options) {
  */
 
 Document.prototype.parent = function() {
-  return this.$__.parent;
+  if (this.$__.isSubDocument || this.$__.wasPopulated) {
+    return this.$__.parent;
+  }
+  return this;
 };
 
 /**