mongoose 6.1.7 → 6.2.0

package/index.d.ts

@@ -74,8 +74,8 @@ declare module 'mongoose' {
      * the model's schema except the `_id` index, and build any indexes that
      * are in your schema but not in MongoDB.
      */
-  export function syncIndexes(options?: Record<string, unknown>): Promise<Array<string>>;
-  export function syncIndexes(options: Record<string, unknown> | null, callback: Callback<Array<string>>): void;
+  export function syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
+  export function syncIndexes(options: SyncIndexesOptions | null, callback: Callback<ConnectionSyncIndexesResult>): 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. */
@@ -165,6 +165,7 @@ declare module 'mongoose' {
   export const version: string;
 
   export type CastError = Error.CastError;
+  export type SyncIndexesError = Error.SyncIndexesError;
 
   type Mongoose = typeof mongoose;
 
@@ -442,14 +443,14 @@ declare module 'mongoose' {
      * the model's schema except the `_id` index, and build any indexes that
      * are in your schema but not in MongoDB.
      */
-    syncIndexes(options?: Record<string, unknown>): Promise<Array<string>>;
-    syncIndexes(options: Record<string, unknown> | null, callback: Callback<Array<string>>): void;
+    syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
+    syncIndexes(options: SyncIndexesOptions | null, callback: Callback<ConnectionSyncIndexesResult>): void;
 
     /**
      * _Requires MongoDB >= 3.6.0._ Executes the wrapped async function
      * in a transaction. Mongoose will commit the transaction if the
      * async function executes successfully and attempt to retry if
-     * there was a retriable error.
+     * there was a retryable error.
      */
     transaction(fn: (session: mongodb.ClientSession) => Promise<any>): Promise<any>;
 
@@ -768,6 +769,12 @@ declare module 'mongoose' {
     toDrop: Array<any>
   }
 
+  interface ModifyResult<T> {
+    value: Require_id<T> | null;
+    lastErrorObject?: mongodb.Document;
+    ok: 0 | 1;
+  }
+
   export const Model: Model<any>;
   interface Model<T, TQueryHelpers = {}, TMethods = {}, TVirtuals = {}> extends NodeJS.EventEmitter, AcceptsDiscriminator {
     new<DocType = AnyKeys<T> & AnyObject>(doc?: DocType, fields?: any | null, options?: boolean | AnyObject): HydratedDocument<T, TMethods, TVirtuals>;
@@ -799,7 +806,7 @@ declare module 'mongoose' {
      * sending multiple `save()` calls because with `bulkSave()` there is only one
      * network round trip to the MongoDB server.
      */
-    bulkSave(documents: Array<Document>): Promise<mongodb.BulkWriteResult>;
+    bulkSave(documents: Array<Document>, options?: mongodb.BulkWriteOptions): Promise<mongodb.BulkWriteResult>;
 
     /** Collection the model uses. */
     collection: Collection;
@@ -877,10 +884,10 @@ declare module 'mongoose' {
      * equivalent to `findOne({ _id: id })`. If you want to query by a document's
      * `_id`, use `findById()` instead of `findOne()`.
      */
-    findById(id: any, projection?: any | null, options?: QueryOptions | null, callback?: Callback<HydratedDocument<T, TMethods, TVirtuals> | null>): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findById<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(id: any, projection?: any | null, options?: QueryOptions | null, callback?: Callback<ResultDoc | null>): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Finds one document. */
-    findOne(filter?: FilterQuery<T>, projection?: any | null, options?: QueryOptions | null, callback?: Callback<HydratedDocument<T, TMethods, TVirtuals> | null>): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findOne<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, projection?: any | null, options?: QueryOptions | null, callback?: Callback<ResultDoc | null>): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /**
      * Shortcut for creating a new Document from existing raw data, pre-saved in the DB.
@@ -972,45 +979,45 @@ declare module 'mongoose' {
     estimatedDocumentCount(options?: QueryOptions, callback?: Callback<number>): QueryWithHelpers<number, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
 
     /**
-     * Returns true if at least one document exists in the database that matches
-     * the given `filter`, and false otherwise.
+     * Returns a document with its `_id` if at least one document exists in the database that matches
+     * the given `filter`, and `null` otherwise.
      */
-    exists(filter: FilterQuery<T>): Promise<boolean>;
-    exists(filter: FilterQuery<T>, callback: Callback<boolean>): void;
+    exists(filter: FilterQuery<T>): QueryWithHelpers<Pick<Document<T>, '_id'> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    exists(filter: FilterQuery<T>, callback: Callback<Pick<Document<T>, '_id'> | null>): QueryWithHelpers<Pick<Document<T>, '_id'> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
 
     /** Creates a `find` query: gets a list of documents that match `filter`. */
-    find(callback?: Callback<HydratedDocument<T, TMethods, TVirtuals>[]>): QueryWithHelpers<Array<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    find(filter: FilterQuery<T>, callback?: Callback<T[]>): QueryWithHelpers<Array<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    find(filter: FilterQuery<T>, projection?: any | null, options?: QueryOptions | null, callback?: Callback<HydratedDocument<T, TMethods, TVirtuals>[]>): QueryWithHelpers<Array<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    find<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(callback?: Callback<ResultDoc[]>): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
+    find<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter: FilterQuery<T>, callback?: Callback<ResultDoc[]>): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
+    find<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter: FilterQuery<T>, projection?: any | null, options?: QueryOptions | null, callback?: Callback<ResultDoc[]>): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findByIdAndDelete` query, filtering by the given `_id`. */
-    findByIdAndDelete(id?: mongodb.ObjectId | any, options?: QueryOptions | null, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals> | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findByIdAndDelete<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(id?: mongodb.ObjectId | any, options?: QueryOptions | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findByIdAndRemove` query, filtering by the given `_id`. */
-    findByIdAndRemove(id?: mongodb.ObjectId | any, options?: QueryOptions | null, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals> | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findByIdAndRemove<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(id?: mongodb.ObjectId | any, options?: QueryOptions | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findOneAndUpdate` query, filtering by the given `_id`. */
-    findByIdAndUpdate(id: mongodb.ObjectId | any, update: UpdateQuery<T>, options: QueryOptions & { rawResult: true }, callback?: (err: CallbackError, doc: any, res: any) => void): QueryWithHelpers<mongodb.ModifyResult<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    findByIdAndUpdate(id: mongodb.ObjectId | any, update: UpdateQuery<T>, options: QueryOptions & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals>, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    findByIdAndUpdate(id?: mongodb.ObjectId | any, update?: UpdateQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals> | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    findByIdAndUpdate(id: mongodb.ObjectId | any, update: UpdateQuery<T>, callback: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals> | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findByIdAndUpdate<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(id: mongodb.ObjectId | any, update: UpdateQuery<T>, options: QueryOptions & { rawResult: true }, callback?: (err: CallbackError, doc: any, res: any) => void): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, T>;
+    findByIdAndUpdate<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(id: mongodb.ObjectId | any, update: UpdateQuery<T>, options: QueryOptions & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: ResultDoc, res: any) => void): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, T>;
+    findByIdAndUpdate<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(id?: mongodb.ObjectId | any, update?: UpdateQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
+    findByIdAndUpdate<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(id: mongodb.ObjectId | any, update: UpdateQuery<T>, callback: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findOneAndDelete` query: atomically finds the given document, deletes it, and returns the document as it was before deletion. */
-    findOneAndDelete(filter?: FilterQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals> | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findOneAndDelete<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findOneAndRemove` query: atomically finds the given document and deletes it. */
-    findOneAndRemove(filter?: FilterQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals> | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findOneAndRemove<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findOneAndReplace` query: atomically finds the given document and replaces it with `replacement`. */
-    findOneAndReplace(filter: FilterQuery<T>, replacement: T | AnyObject, options: QueryOptions & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals>, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    findOneAndReplace(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions | null, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals> | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findOneAndReplace<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter: FilterQuery<T>, replacement: T | AnyObject, options: QueryOptions & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: ResultDoc, res: any) => void): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, T>;
+    findOneAndReplace<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions | null, callback?: (err: CallbackError, doc: ResultDoc | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `findOneAndUpdate` query: atomically find the first document that matches `filter` and apply `update`. */
-    findOneAndUpdate(filter: FilterQuery<T>, update: UpdateQuery<T>, options: QueryOptions & { rawResult: true }, callback?: (err: CallbackError, doc: any, res: any) => void): QueryWithHelpers<mongodb.ModifyResult<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    findOneAndUpdate(filter: FilterQuery<T>, update: UpdateQuery<T>, options: QueryOptions & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: HydratedDocument<T, TMethods, TVirtuals>, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    findOneAndUpdate(filter?: FilterQuery<T>, update?: UpdateQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: T | null, res: any) => void): QueryWithHelpers<HydratedDocument<T, TMethods, TVirtuals> | null, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    findOneAndUpdate<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter: FilterQuery<T>, update: UpdateQuery<T>, options: QueryOptions & { rawResult: true }, callback?: (err: CallbackError, doc: any, res: any) => void): QueryWithHelpers<ModifyResult<ResultDoc>, ResultDoc, TQueryHelpers, T>;
+    findOneAndUpdate<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter: FilterQuery<T>, update: UpdateQuery<T>, options: QueryOptions & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: ResultDoc, res: any) => void): QueryWithHelpers<ResultDoc, ResultDoc, TQueryHelpers, T>;
+    findOneAndUpdate<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, update?: UpdateQuery<T>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: T | null, res: any) => void): QueryWithHelpers<ResultDoc | null, ResultDoc, TQueryHelpers, T>;
 
-    geoSearch(filter?: FilterQuery<T>, options?: GeoSearchOptions, callback?: Callback<Array<HydratedDocument<T, TMethods, TVirtuals>>>): QueryWithHelpers<Array<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    geoSearch<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, options?: GeoSearchOptions, callback?: Callback<Array<ResultDoc>>): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
 
     /** Executes a mapReduce command. */
     mapReduce<Key, Value>(
@@ -1018,11 +1025,11 @@ declare module 'mongoose' {
       callback?: Callback
     ): Promise<any>;
 
-    remove(filter?: any, callback?: CallbackWithoutResult): QueryWithHelpers<any, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    remove<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: any, callback?: CallbackWithoutResult): QueryWithHelpers<any, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `replaceOne` query: finds the first document that matches `filter` and replaces it with `replacement`. */
-    replaceOne(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<any, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    replaceOne(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<any, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    replaceOne<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<any, ResultDoc, TQueryHelpers, T>;
+    replaceOne<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, replacement?: T | AnyObject, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<any, ResultDoc, TQueryHelpers, T>;
 
     /** Schema the model uses. */
     schema: Schema<T>;
@@ -1031,18 +1038,18 @@ declare module 'mongoose' {
      * @deprecated use `updateOne` or `updateMany` instead.
      * Creates a `update` query: updates one or many documents that match `filter` with `update`, based on the `multi` option.
      */
-    update(filter?: FilterQuery<T>, update?: UpdateQuery<T> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<UpdateWriteOpResult, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    update<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, update?: UpdateQuery<T> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `updateMany` query: updates all documents that match `filter` with `update`. */
-    updateMany(filter?: FilterQuery<T>, update?: UpdateQuery<T> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<UpdateWriteOpResult, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    updateMany<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, update?: UpdateQuery<T> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a `updateOne` query: updates the first document that matches `filter` with `update`. */
-    updateOne(filter?: FilterQuery<T>, update?: UpdateQuery<T> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<UpdateWriteOpResult, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    updateOne<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(filter?: FilterQuery<T>, update?: UpdateQuery<T> | UpdateWithAggregationPipeline, options?: QueryOptions | null, callback?: Callback): QueryWithHelpers<UpdateWriteOpResult, ResultDoc, TQueryHelpers, T>;
 
     /** Creates a Query, applies the passed conditions, and returns the Query. */
-    where(path: string, val?: any): QueryWithHelpers<Array<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    where(obj: object): QueryWithHelpers<Array<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
-    where(): QueryWithHelpers<Array<HydratedDocument<T, TMethods, TVirtuals>>, HydratedDocument<T, TMethods, TVirtuals>, TQueryHelpers, T>;
+    where<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(path: string, val?: any): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
+    where<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(obj: object): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
+    where<ResultDoc = HydratedDocument<T, TMethods, TVirtuals>>(): QueryWithHelpers<Array<ResultDoc>, ResultDoc, TQueryHelpers, T>;
   }
 
   type UpdateWriteOpResult = mongodb.UpdateResult;
@@ -1505,6 +1512,11 @@ declare module 'mongoose' {
      * optimistic concurrency.
      */
     optimisticConcurrency?: boolean;
+    /**
+     * If `plugin()` called with tags, Mongoose will only apply plugins to schemas that have
+     * a matching tag in `pluginTags`
+     */
+    pluginTags?: string[];
     /**
      * Allows setting query#read options at the schema level, providing us a way to apply default ReadPreferences
      * to all queries derived from a model.
@@ -2124,6 +2136,9 @@ 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;
+  type UnpackedIntersectionWithNull<T, U> = T extends null ? UnpackedIntersection<T, U> | null : UnpackedIntersection<T, U>;
+
+  type ProjectionFields<DocType> = {[Key in keyof Omit<LeanDocument<DocType>, '__v'>]?: any} & Record<string, any>;
 
   class Query<ResultType, DocType, THelpers = {}, RawDocType = DocType> {
     _mongooseOptions: MongooseQueryOptions;
@@ -2268,9 +2283,24 @@ declare module 'mongoose' {
     findOneAndRemove(filter?: FilterQuery<DocType>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: DocType | null, res: any) => void): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType>;
 
     /** Creates a `findOneAndUpdate` query: atomically find the first document that matches `filter` and apply `update`. */
-    findOneAndUpdate(filter: FilterQuery<DocType>, update: UpdateQuery<DocType>, options: QueryOptions & { rawResult: true }, callback?: (err: CallbackError, doc: DocType | null, res: mongodb.ModifyResult<DocType>) => void): QueryWithHelpers<mongodb.ModifyResult<DocType>, DocType, THelpers, RawDocType>;
-    findOneAndUpdate(filter: FilterQuery<DocType>, update: UpdateQuery<DocType>, options: QueryOptions & { upsert: true } & ReturnsNewDoc, callback?: (err: CallbackError, doc: DocType, res: mongodb.ModifyResult<DocType>) => void): QueryWithHelpers<DocType, DocType, THelpers, RawDocType>;
-    findOneAndUpdate(filter?: FilterQuery<DocType>, update?: UpdateQuery<DocType>, options?: QueryOptions | null, callback?: (err: CallbackError, doc: DocType | null, res: mongodb.ModifyResult<DocType>) => void): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType>;
+    findOneAndUpdate(
+      filter: FilterQuery<DocType>,
+      update: UpdateQuery<DocType>,
+      options: QueryOptions & { rawResult: true },
+      callback?: (err: CallbackError, doc: DocType | null, res: ModifyResult<DocType>) => void
+    ): QueryWithHelpers<ModifyResult<DocType>, DocType, THelpers, RawDocType>;
+    findOneAndUpdate(
+      filter: FilterQuery<DocType>,
+      update: UpdateQuery<DocType>,
+      options: QueryOptions & { upsert: true } & ReturnsNewDoc,
+      callback?: (err: CallbackError, doc: DocType, res: ModifyResult<DocType>) => void
+    ): QueryWithHelpers<DocType, DocType, THelpers, RawDocType>;
+    findOneAndUpdate(
+      filter?: FilterQuery<DocType>,
+      update?: UpdateQuery<DocType>,
+      options?: QueryOptions | null,
+      callback?: (err: CallbackError, doc: DocType | null, res: ModifyResult<DocType>) => void
+    ): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType>;
 
     /** Creates a `findByIdAndDelete` query, filtering by the given `_id`. */
     findByIdAndDelete(id?: mongodb.ObjectId | any, options?: QueryOptions | null, callback?: (err: CallbackError, doc: DocType | null, res: any) => void): QueryWithHelpers<DocType | null, DocType, THelpers, RawDocType>;
@@ -2407,11 +2437,13 @@ 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<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
-    populate<Paths = {}>(options: PopulateOptions | Array<PopulateOptions>): QueryWithHelpers<UnpackedIntersection<ResultType, Paths>, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(path: string | any, select?: string | any, model?: string | Model<any, THelpers>, match?: any): QueryWithHelpers<UnpackedIntersectionWithNull<ResultType, Paths>, DocType, THelpers, RawDocType>;
+    populate<Paths = {}>(options: PopulateOptions | Array<PopulateOptions>): QueryWithHelpers<UnpackedIntersectionWithNull<ResultType, Paths>, DocType, THelpers, RawDocType>;
 
     /** Get/set the current projection (AKA fields). Pass `null` to remove the current projection. */
-    projection(fields?: any | null): this;
+    projection(): ProjectionFields<DocType> | null;
+    projection(fields: null): null;
+    projection(fields?: ProjectionFields<DocType> | string): ProjectionFields<DocType>;
 
     /** Determines the MongoDB nodes from which to read. */
     read(pref: string | mongodb.ReadPreferenceMode, tags?: any[]): this;
@@ -3261,9 +3293,15 @@ declare module 'mongoose' {
     /** String representation of what type this is, like 'ObjectID' or 'Number' */
     instance: string;
 
+    /** True if this SchemaType has a required validator. False otherwise. */
+    isRequired?: boolean;
+
     /** The options this SchemaType was instantiated with */
     options: AnyObject;
 
+    /** The path to this SchemaType in a Schema. */
+    path: string;
+
     /**
      * Set the model that this path refers to. This is the option that [populate](https://mongoosejs.com/docs/populate.html)
      * looks at to determine the foreign collection it should query.
@@ -3297,11 +3335,19 @@ declare module 'mongoose' {
     /** Declares an unique index. */
     unique(bool: boolean): this;
 
+    /** The validators that Mongoose should run to validate properties at this SchemaType's path. */
+    validators: { message?: string; type?: string; validator?: Function }[];
+
     /** Adds validator(s) for this document path. */
     validate(obj: RegExp | Function | any, errorMsg?: string,
       type?: string): this;
   }
 
+  export interface SyncIndexesOptions extends mongodb.CreateIndexesOptions {
+    continueOnError?: boolean
+  }
+  export type ConnectionSyncIndexesResult = Record<string, OneCollectionSyncIndexesResult>;
+  type OneCollectionSyncIndexesResult = Array<string> & mongodb.MongoServerError;
   type Callback<T = any> = (error: CallbackError, result: T) => void;
 
   type CallbackWithoutResult = (error: CallbackError) => void;
@@ -3332,6 +3378,12 @@ declare module 'mongoose' {
 
       constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
     }
+    export class SyncIndexesError extends Error {
+      name: 'SyncIndexesError';
+      errors?: Record<string, mongodb.MongoServerError>;
+
+      constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
+    }
 
     export class DisconnectedError extends Error {
       name: 'DisconnectedError';

package/lib/aggregate.js

@@ -11,7 +11,6 @@ const getConstructorName = require('./helpers/getConstructorName');
 const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
 const stringifyFunctionOperators = require('./helpers/aggregate/stringifyFunctionOperators');
-const util = require('util');
 const utils = require('./utils');
 const read = Query.prototype.read;
 const readConcern = Query.prototype.readConcern;
@@ -55,7 +54,7 @@ function Aggregate(pipeline, model) {
   this._model = model;
   this.options = {};
 
-  if (arguments.length === 1 && util.isArray(pipeline)) {
+  if (arguments.length === 1 && Array.isArray(pipeline)) {
     this.append.apply(this, pipeline);
   }
 }
@@ -138,9 +137,9 @@ Aggregate.prototype.model = function(model) {
  */
 
 Aggregate.prototype.append = function() {
-  const args = (arguments.length === 1 && util.isArray(arguments[0]))
+  const args = (arguments.length === 1 && Array.isArray(arguments[0]))
     ? arguments[0]
-    : utils.args(arguments);
+    : [...arguments];
 
   if (!args.every(isOperator)) {
     throw new Error('Arguments must be aggregate pipeline operators');
@@ -176,7 +175,7 @@ Aggregate.prototype.append = function() {
  */
 Aggregate.prototype.addFields = function(arg) {
   const fields = {};
-  if (typeof arg === 'object' && !util.isArray(arg)) {
+  if (typeof arg === 'object' && !Array.isArray(arg)) {
     Object.keys(arg).forEach(function(field) {
       fields[field] = arg[field];
     });
@@ -221,7 +220,7 @@ Aggregate.prototype.addFields = function(arg) {
 Aggregate.prototype.project = function(arg) {
   const fields = {};
 
-  if (typeof arg === 'object' && !util.isArray(arg)) {
+  if (typeof arg === 'object' && !Array.isArray(arg)) {
     Object.keys(arg).forEach(function(field) {
       fields[field] = arg[field];
     });
@@ -372,7 +371,7 @@ Aggregate.prototype.near = function(arg) {
  */
 
 Aggregate.prototype.unwind = function() {
-  const args = utils.args(arguments);
+  const args = [...arguments];
 
   const res = [];
   for (const arg of args) {

package/lib/cast/objectid.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const ObjectId = require('../driver').get().ObjectId;
-const assert = require('assert');
 
 module.exports = function castObjectId(value) {
   if (value == null) {
@@ -25,5 +24,5 @@ module.exports = function castObjectId(value) {
     return new ObjectId(value.toString());
   }
 
-  assert.ok(false);
+  return new ObjectId(value);
 };

package/lib/cast.js

@@ -7,6 +7,7 @@
 const CastError = require('./error/cast');
 const StrictModeError = require('./error/strict');
 const Types = require('./schema/index');
+const cast$expr = require('./helpers/query/cast$expr');
 const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
 const getConstructorName = require('./helpers/getConstructorName');
@@ -36,14 +37,6 @@ module.exports = function cast(schema, obj, options, context) {
     return obj;
   }
 
-  // bson 1.x has the unfortunate tendency to remove filters that have a top-level
-  // `_bsontype` property. But we should still allow ObjectIds because
-  // `Collection#find()` has a special case to support `find(objectid)`.
-  // Should remove this when we upgrade to bson 4.x. See gh-8222, gh-8268
-  if (obj.hasOwnProperty('_bsontype') && obj._bsontype !== 'ObjectID') {
-    delete obj._bsontype;
-  }
-
   if (schema != null && schema.discriminators != null && obj[schema.options.discriminatorKey] != null) {
     schema = getSchemaDiscriminatorByValue(schema, obj[schema.options.discriminatorKey]) || schema;
   }
@@ -87,9 +80,7 @@ module.exports = function cast(schema, obj, options, context) {
 
       continue;
     } else if (path === '$expr') {
-      if (typeof val !== 'object' || val == null) {
-        throw new Error('`$expr` must be an object');
-      }
+      val = cast$expr(val, schema);
       continue;
     } else if (path === '$elemMatch') {
       val = cast(schema, val, options, context);
@@ -153,7 +144,13 @@ module.exports = function cast(schema, obj, options, context) {
             remainingConds = {};
             pathLastHalf = split.slice(j).join('.');
             remainingConds[pathLastHalf] = val;
-            obj[path] = cast(schematype.caster.schema, remainingConds, options, context)[pathLastHalf];
+
+            const ret = cast(schematype.caster.schema, remainingConds, options, context)[pathLastHalf];
+            if (ret === void 0) {
+              delete obj[path];
+            } else {
+              obj[path] = ret;
+            }
           } else {
             obj[path] = val;
           }
@@ -259,16 +256,24 @@ module.exports = function cast(schema, obj, options, context) {
         if (schema.nested[path]) {
           continue;
         }
-        if (options.upsert && options.strict) {
-          if (options.strict === 'throw') {
+
+        const strict = 'strict' in options ? options.strict : schema.options.strict;
+        const strictQuery = 'strictQuery' in options ?
+          options.strictQuery :
+          'strict' in options ?
+            options.strict :
+            'strict' in schema._userProvidedOptions ? schema._userProvidedOptions.strict :
+              schema.options.strictQuery;
+        if (options.upsert && strict) {
+          if (strict === 'throw') {
             throw new StrictModeError(path);
           }
           throw new StrictModeError(path, 'Path "' + path + '" is not in ' +
             'schema, strict mode is `true`, and upsert is `true`.');
-        } if (options.strictQuery === 'throw') {
+        } if (strictQuery === 'throw') {
           throw new StrictModeError(path, 'Path "' + path + '" is not in ' +
             'schema and strictQuery is \'throw\'.');
-        } else if (options.strictQuery) {
+        } else if (strictQuery) {
           delete obj[path];
         }
       } else if (val == null) {

package/lib/connection.js

@@ -10,6 +10,7 @@ const Schema = require('./schema');
 const Collection = require('./driver').get().Collection;
 const STATES = require('./connectionstate');
 const MongooseError = require('./error/index');
+const SyncIndexesError = require('./error/syncIndexes');
 const PromiseProvider = require('./promise_provider');
 const ServerSelectionError = require('./error/serverSelection');
 const applyPlugins = require('./helpers/schema/applyPlugins');
@@ -504,6 +505,10 @@ Connection.prototype.transaction = function transaction(fn, options) {
         }
         delete session[sessionNewDocuments];
         throw err;
+      })
+      .finally(() => {
+        session.endSession()
+          .catch(() => {});
       });
   });
 };
@@ -1376,11 +1381,40 @@ Connection.prototype.setClient = function setClient(client) {
   return this;
 };
 
-Connection.prototype.syncIndexes = async function syncIndexes() {
+/**
+ *
+ * Syncs all the indexes for the models registered with this connection.
+ *
+ * @param {Object} options
+ * @param {Boolean} options.continueOnError `false` by default. If set to `true`, mongoose will not throw an error if one model syncing failed, and will return an object where the keys are the names of the models, and the values are the results/errors for each model.
+ * @returns
+ */
+Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
   const result = {};
-  for (const model in this.models) {
-    result[model] = await this.model(model).syncIndexes();
+  const errorsMap = { };
+
+  const { continueOnError } = options;
+  delete options.continueOnError;
+
+  for (const model of Object.values(this.models)) {
+    try {
+      result[model.modelName] = await model.syncIndexes(options);
+    } catch (err) {
+      if (!continueOnError) {
+        errorsMap[model.modelName] = err;
+        break;
+      } else {
+        result[model.modelName] = err;
+      }
+    }
   }
+
+  if (!continueOnError && Object.keys(errorsMap).length) {
+    const message = Object.entries(errorsMap).map(([modelName, err]) => `${modelName}: ${err.message}`).join(', ');
+    const syncIndexesError = new SyncIndexesError(message, errorsMap);
+    throw syncIndexesError;
+  }
+
   return result;
 };
 

package/lib/document.js

@@ -885,7 +885,7 @@ function init(self, obj, doc, opts, prefix) {
  */
 
 Document.prototype.update = function update() {
-  const args = utils.args(arguments);
+  const args = [...arguments];
   args.unshift({ _id: this._id });
   const query = this.constructor.update.apply(this.constructor, args);
 
@@ -962,7 +962,7 @@ Document.prototype.updateOne = function updateOne(doc, options, callback) {
  */
 
 Document.prototype.replaceOne = function replaceOne() {
-  const args = utils.args(arguments);
+  const args = [...arguments];
   args.unshift({ _id: this._id });
   return this.constructor.replaceOne.apply(this.constructor, args);
 };
@@ -3801,7 +3801,7 @@ function applyVirtuals(self, json, options, toObjectOptions) {
       if (!path.startsWith(options.path + '.')) {
         continue;
       }
-      assignPath = path.substr(options.path.length + 1);
+      assignPath = path.substring(options.path.length + 1);
     }
     const parts = assignPath.split('.');
     v = clone(self.get(path), options);
@@ -4136,7 +4136,7 @@ Document.prototype.equals = function(doc) {
 
 Document.prototype.populate = function populate() {
   const pop = {};
-  const args = utils.args(arguments);
+  const args = [...arguments];
   let fn;
 
   if (args.length > 0) {

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

@@ -10,7 +10,6 @@ const Collection = require('mongodb').Collection;
 const ObjectId = require('./objectid');
 const get = require('../../helpers/get');
 const getConstructorName = require('../../helpers/getConstructorName');
-const sliced = require('sliced');
 const stream = require('stream');
 const util = require('util');
 
@@ -173,7 +172,7 @@ function iter(i) {
     if (debug) {
       if (typeof debug === 'function') {
         debug.apply(_this,
-          [_this.name, i].concat(sliced(args, 0, args.length - 1)));
+          [_this.name, i].concat(args.slice(0, args.length - 1)));
       } else if (debug instanceof stream.Writable) {
         this.$printToStream(_this.name, i, args, debug);
       } else {

package/lib/error/index.js

@@ -181,6 +181,17 @@ MongooseError.OverwriteModelError = require('./overwriteModel');
 
 MongooseError.MissingSchemaError = require('./missingSchema');
 
+/**
+ * Thrown when the MongoDB Node driver can't connect to a valid server
+ * to send an operation to.
+ *
+ * @api public
+ * @memberOf Error
+ * @static MongooseServerSelectionError
+ */
+
+MongooseError.MongooseServerSelectionError = require('./serverSelection');
+
 /**
  * An instance of this error will be returned if you used an array projection
  * and then modified the array in an unsafe way.

package/lib/error/syncIndexes.js

@@ -0,0 +1,30 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const MongooseError = require('./mongooseError');
+
+/**
+ * SyncIndexes Error constructor.
+ *
+ * @param {String} message
+ * @param {String} errorsMap
+ * @inherits MongooseError
+ * @api private
+ */
+
+class SyncIndexesError extends MongooseError {
+  constructor(message, errorsMap) {
+    super(message);
+    this.errors = errorsMap;
+  }
+}
+
+Object.defineProperty(SyncIndexesError.prototype, 'name', {
+  value: 'SyncIndexesError'
+});
+
+
+module.exports = SyncIndexesError;