Merge branch 'master' into 8.11

Author: vkarpov15

lib/connection.js

@@ -818,32 +818,41 @@ Connection.prototype.dropCollection = async function dropCollection(collection)
 /**
  * Waits for connection to be established, so the connection has a `client`
  *
+ * @param {Boolean} [noTimeout=false] if set, don't put a timeout on the operation. Used internally so `mongoose.model()` doesn't leave open handles.
  * @return Promise
  * @api private
  */
 
-Connection.prototype._waitForConnect = async function _waitForConnect() {
+Connection.prototype._waitForConnect = async function _waitForConnect(noTimeout) {
   if ((this.readyState === STATES.connecting || this.readyState === STATES.disconnected) && this._shouldBufferCommands()) {
     const bufferTimeoutMS = this._getBufferTimeoutMS();
     let timeout = null;
     let timedOut = false;
     // The element that this function pushes onto `_queue`, stored to make it easy to remove later
     const queueElement = {};
-    await Promise.race([
-      new Promise(resolve => {
-        queueElement.fn = resolve;
-        this._queue.push(queueElement);
-      }),
-      new Promise(resolve => {
-        timeout = setTimeout(
-          () => {
-            timedOut = true;
-            resolve();
-          },
-          bufferTimeoutMS
-        );
-      })
-    ]);
+
+    // Mongoose executes all elements in `_queue` when initial connection succeeds in `onOpen()`.
+    const waitForConnectPromise = new Promise(resolve => {
+      queueElement.fn = resolve;
+      this._queue.push(queueElement);
+    });
+
+    if (noTimeout) {
+      await waitForConnectPromise;
+    } else {
+      await Promise.race([
+        waitForConnectPromise,
+        new Promise(resolve => {
+          timeout = setTimeout(
+            () => {
+              timedOut = true;
+              resolve();
+            },
+            bufferTimeoutMS
+          );
+        })
+      ]);
+    }
 
     if (timedOut) {
       const index = this._queue.indexOf(queueElement);

lib/document.js

@@ -741,15 +741,10 @@ function init(self, obj, doc, opts, prefix) {
   let schemaType;
   let path;
   let i;
-  let index = 0;
   const strict = self.$__.strictMode;
   const docSchema = self.$__schema;
 
-  while (index < len) {
-    _init(index++);
-  }
-
-  function _init(index) {
+  for (let index = 0; index < len; ++index) {
     i = keys[index];
     // avoid prototype pollution
     if (i === '__proto__' || i === 'constructor') {

lib/model.js

@@ -1103,16 +1103,28 @@ Model.init = function init() {
     return results;
   };
   const _createCollection = async() => {
-    await conn._waitForConnect();
-    const autoCreate = utils.getOption(
+    let autoCreate = utils.getOption(
       'autoCreate',
       this.schema.options,
-      conn.config,
-      conn.base.options
+      conn.config
+      // No base.options here because we don't want to take the base value if the connection hasn't
+      // set it yet
     );
+    if (autoCreate == null) {
+      // `autoCreate` may later be set when the connection is opened, so wait for connect before checking
+      await conn._waitForConnect(true);
+      autoCreate = utils.getOption(
+        'autoCreate',
+        this.schema.options,
+        conn.config,
+        conn.base.options
+      );
+    }
+
     if (!autoCreate) {
       return;
     }
+
     return await this.createCollection();
   };
 

lib/query.js

@@ -65,6 +65,25 @@ const queryOptionMethods = new Set([
   'wtimeout'
 ]);
 
+// Map from operation name to the name of the function that executes the actual operation against MongoDB.
+// Called a thunk for legacy reasons, "thunk" means function that takes exactly 1 param, a callback.
+// Currently `_countDocuments()`, etc. are async functions that take no params.
+const opToThunk = new Map([
+  ['countDocuments', '_countDocuments'],
+  ['distinct', '__distinct'],
+  ['estimatedDocumentCount', '_estimatedDocumentCount'],
+  ['find', '_find'],
+  ['findOne', '_findOne'],
+  ['findOneAndReplace', '_findOneAndReplace'],
+  ['findOneAndUpdate', '_findOneAndUpdate'],
+  ['replaceOne', '_replaceOne'],
+  ['updateMany', '_updateMany'],
+  ['updateOne', '_updateOne'],
+  ['deleteMany', '_deleteMany'],
+  ['deleteOne', '_deleteOne'],
+  ['findOneAndDelete', '_findOneAndDelete']
+]);
+
 /**
  * Query constructor used for building queries. You do not need
  * to instantiate a `Query` directly. Instead use Model functions like
@@ -2337,18 +2356,17 @@ Query.prototype._find = async function _find() {
   }
 
   const mongooseOptions = this._mongooseOptions;
-  const _this = this;
-  const userProvidedFields = _this._userProvidedFields || {};
+  const userProvidedFields = this._userProvidedFields || {};
 
   applyGlobalMaxTimeMS(this.options, this.model.db.options, this.model.base.options);
   applyGlobalDiskUse(this.options, this.model.db.options, this.model.base.options);
 
   // Separate options to pass down to `completeMany()` in case we need to
   // set a session on the document
-  const completeManyOptions = Object.assign({}, {
+  const completeManyOptions = {
     session: this && this.options && this.options.session || null,
     lean: mongooseOptions.lean || null
-  });
+  };
 
   const options = this._optionsForExec();
 
@@ -2366,7 +2384,7 @@ Query.prototype._find = async function _find() {
   }
 
   if (!mongooseOptions.populate) {
-    const versionKey = _this.schema.options.versionKey;
+    const versionKey = this.schema.options.versionKey;
     if (mongooseOptions.lean && mongooseOptions.lean.versionKey === false && versionKey) {
       docs.forEach((doc) => {
         if (versionKey in doc) {
@@ -2375,17 +2393,17 @@ Query.prototype._find = async function _find() {
       });
     }
     return mongooseOptions.lean ?
-      _completeManyLean(_this.model.schema, docs, null, completeManyOptions) :
-      _this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
+      _completeManyLean(this.model.schema, docs, null, completeManyOptions) :
+      this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
   }
 
-  const pop = helpers.preparePopulationOptionsMQ(_this, mongooseOptions);
+  const pop = helpers.preparePopulationOptionsMQ(this, mongooseOptions);
 
   if (mongooseOptions.lean) {
-    return _this.model.populate(docs, pop);
+    return this.model.populate(docs, pop);
   }
 
-  docs = await _this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
+  docs = await this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
   await this.model.populate(docs, pop);
 
   return docs;
@@ -4397,22 +4415,14 @@ Query.prototype.exec = async function exec(op) {
   if (this.model == null) {
     throw new MongooseError('Query must have an associated model before executing');
   }
-  this._validateOp();
-
-  if (!this.op) {
-    return;
-  }
 
-  if (this.options && this.options.sort) {
-    const keys = Object.keys(this.options.sort);
-    if (keys.includes('')) {
-      throw new Error('Invalid field "" passed to sort()');
-    }
+  const thunk = opToThunk.get(this.op);
+  if (!thunk) {
+    throw new MongooseError('Query has invalid `op`: "' + this.op + '"');
   }
 
-  let thunk = '_' + this.op;
-  if (this.op === 'distinct') {
-    thunk = '__distinct';
+  if (this.options && this.options.sort && typeof this.options.sort === 'object' && this.options.sort.hasOwnProperty('')) {
+    throw new Error('Invalid field "" passed to sort()');
   }
 
   if (this._executionStack != null) {

test/connection.test.js

@@ -1637,6 +1637,19 @@ describe('connections:', function() {
     assert.ok(!res.map(c => c.name).includes('gh12940_Conn'));
   });
 
+  it('does not wait for buffering if autoCreate: false (gh-15241)', async function() {
+    const m = new mongoose.Mongoose();
+    m.set('bufferTimeoutMS', 100);
+
+    const schema = new Schema({ name: String }, {
+      autoCreate: false
+    });
+    const Model = m.model('gh15241_Conn', schema);
+
+    // Without gh-15241 changes, this would buffer and fail even though `autoCreate: false`
+    await Model.init();
+  });
+
   it('should not create default connection with createInitialConnection = false (gh-12965)', function() {
     const m = new mongoose.Mongoose({
       createInitialConnection: false

test/types/middleware.test.ts

@@ -200,3 +200,60 @@ function gh13601() {
     expectAssignable<Document>(this);
   });
 }
+
+function gh15242() {
+  type PostPersisted = {
+    title: string,
+    postTime: Date
+  };
+
+  type ValidatorThis = DocumentValidatorThis | QueryValidatorThis;
+  type DocumentValidatorThis = HydratedDocument<PostPersisted>;
+  type QueryValidatorThis = Query<PostRecord, PostRecord>;
+
+  const PostSchema = new Schema<PostPersisted>({
+    title: { type: String, required: true },
+    postTime: {
+      type: Date,
+      required: true,
+      validate: {
+        validator: async function(this: ValidatorThis, postTime: Date): Promise<boolean> {
+          return true;
+        }
+      }
+    }
+  });
+
+  type PostRecord = HydratedDocument<PostPersisted>;
+  const PostModel = model<PostPersisted>('Post', PostSchema);
+}
+
+function gh15242WithVirtuals() {
+  type PostPersisted = {
+    title: string,
+    postTime: Date
+  };
+
+  type ValidatorThis = DocumentValidatorThis | QueryValidatorThis;
+  type DocumentValidatorThis = HydratedDocument<PostPersisted, { myVirtual: number }>;
+  type QueryValidatorThis = Query<PostRecord, PostRecord>;
+
+  const PostSchema = new Schema({
+    title: { type: String, required: true },
+    postTime: {
+      type: Date,
+      required: true,
+      validate: {
+        validator: async function(this: ValidatorThis, postTime: Date): Promise<boolean> {
+          if (!(this instanceof Query)) {
+            expectType<number>(this.myVirtual);
+          }
+          return true;
+        }
+      }
+    }
+  }, { virtuals: { myVirtual: { get() { return 42; } } } });
+
+  type PostRecord = HydratedDocument<PostPersisted, { myVirtual: number }>;
+  const PostModel = model<PostPersisted>('Post', PostSchema);
+}

test/types/schema.test.ts

@@ -1733,3 +1733,8 @@ async function gh15236() {
 
   schema.path<Schema.Types.Number>('myNum').min(0);
 }
+
+function gh15244() {
+  const schema = new Schema({});
+  schema.discriminator('Name', new Schema({}), { value: 'value' });
+}

types/index.d.ts

@@ -273,10 +273,10 @@ declare module 'mongoose' {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType> | DocType, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
+    constructor(definition?: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType, THydratedDocumentType> | DocType, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
 
     /** Adds key path / schema type pairs to this schema. */
-    add(obj: SchemaDefinition<SchemaDefinitionType<RawDocType>> | Schema, prefix?: string): this;
+    add(obj: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType> | Schema, prefix?: string): this;
 
     /**
      * Add an alias for `path`. This means getting or setting the `alias`
@@ -297,7 +297,7 @@ declare module 'mongoose' {
     /** Returns a copy of this schema */
     clone<T = this>(): T;
 
-    discriminator<DisSchema = Schema>(name: string | number, schema: DisSchema): this;
+    discriminator<DisSchema = Schema>(name: string | number, schema: DisSchema, options?: DiscriminatorOptions): this;
 
     /** Returns a new schema that has the picked `paths` from this schema. */
     pick<T = this>(paths: string[], options?: SchemaOptions): T;
@@ -541,21 +541,21 @@ declare module 'mongoose' {
           ? DateSchemaDefinition
           : (Function | string);
 
-  export type SchemaDefinitionProperty<T = undefined, EnforcedDocType = any> = SchemaDefinitionWithBuiltInClass<T> |
-  SchemaTypeOptions<T extends undefined ? any : T, EnforcedDocType> |
-    typeof SchemaType |
-  Schema<any, any, any> |
-  Schema<any, any, any>[] |
-  SchemaTypeOptions<T extends undefined ? any : Unpacked<T>, EnforcedDocType>[] |
-  Function[] |
-  SchemaDefinition<T, EnforcedDocType> |
-  SchemaDefinition<Unpacked<T>, EnforcedDocType>[] |
-    typeof Schema.Types.Mixed |
-  MixedSchemaTypeOptions<EnforcedDocType>;
-
-  export type SchemaDefinition<T = undefined, EnforcedDocType = any> = T extends undefined
+  export type SchemaDefinitionProperty<T = undefined, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> = SchemaDefinitionWithBuiltInClass<T>
+    | SchemaTypeOptions<T extends undefined ? any : T, EnforcedDocType, THydratedDocumentType>
+    | typeof SchemaType
+    | Schema<any, any, any>
+    | Schema<any, any, any>[]
+    | SchemaTypeOptions<T extends undefined ? any : Unpacked<T>, EnforcedDocType, THydratedDocumentType>[]
+    | Function[]
+    | SchemaDefinition<T, EnforcedDocType, THydratedDocumentType>
+    | SchemaDefinition<Unpacked<T>, EnforcedDocType, THydratedDocumentType>[]
+    | typeof Schema.Types.Mixed
+    | MixedSchemaTypeOptions<EnforcedDocType>;
+
+  export type SchemaDefinition<T = undefined, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> = T extends undefined
     ? { [path: string]: SchemaDefinitionProperty; }
-    : { [path in keyof T]?: SchemaDefinitionProperty<T[path], EnforcedDocType>; };
+    : { [path in keyof T]?: SchemaDefinitionProperty<T[path], EnforcedDocType, THydratedDocumentType>; };
 
   export type AnyArray<T> = T[] | ReadonlyArray<T>;
   export type ExtractMongooseArray<T> = T extends Types.Array<any> ? AnyArray<Unpacked<T>> : T;

types/schematypes.d.ts

@@ -56,7 +56,7 @@ declare module 'mongoose' {
 
   type DefaultType<T> = T extends Schema.Types.Mixed ? any : Partial<ExtractMongooseArray<T>>;
 
-  class SchemaTypeOptions<T, EnforcedDocType = any> {
+  class SchemaTypeOptions<T, EnforcedDocType = any, THydratedDocumentType = HydratedDocument<EnforcedDocType>> {
     type?:
     T extends string ? StringSchemaDefinition :
       T extends number ? NumberSchemaDefinition :
@@ -65,19 +65,19 @@ declare module 'mongoose' {
             T extends Map<any, any> ? SchemaDefinition<typeof Map> :
               T extends Buffer ? SchemaDefinition<typeof Buffer> :
                 T extends Types.ObjectId ? ObjectIdSchemaDefinition :
-                  T extends Types.ObjectId[] ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<ObjectId, EnforcedDocType>> :
-                    T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType>>) :
-                      T extends string[] ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string, EnforcedDocType>> :
-                        T extends number[] ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number, EnforcedDocType>> :
-                          T extends boolean[] ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean, EnforcedDocType>> :
-                            T extends Function[] ? AnyArray<Function | string> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType>> :
+                  T extends Types.ObjectId[] ? AnyArray<ObjectIdSchemaDefinition> | AnyArray<SchemaTypeOptions<ObjectId, EnforcedDocType, THydratedDocumentType>> :
+                    T extends object[] ? (AnyArray<Schema<any, any, any>> | AnyArray<SchemaDefinition<Unpacked<T>>> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType, THydratedDocumentType>>) :
+                      T extends string[] ? AnyArray<StringSchemaDefinition> | AnyArray<SchemaTypeOptions<string, EnforcedDocType, THydratedDocumentType>> :
+                        T extends number[] ? AnyArray<NumberSchemaDefinition> | AnyArray<SchemaTypeOptions<number, EnforcedDocType, THydratedDocumentType>> :
+                          T extends boolean[] ? AnyArray<BooleanSchemaDefinition> | AnyArray<SchemaTypeOptions<boolean, EnforcedDocType, THydratedDocumentType>> :
+                            T extends Function[] ? AnyArray<Function | string> | AnyArray<SchemaTypeOptions<Unpacked<T>, EnforcedDocType, THydratedDocumentType>> :
                               T | typeof SchemaType | Schema<any, any, any> | SchemaDefinition<T> | Function | AnyArray<Function>;
 
     /** Defines a virtual with the given name that gets/sets this path. */
     alias?: string | string[];
 
     /** Function or object describing how to validate this schematype. See [validation docs](https://mongoosejs.com/docs/validation.html). */
-    validate?: SchemaValidator<T, EnforcedDocType> | AnyArray<SchemaValidator<T, EnforcedDocType>>;
+    validate?: SchemaValidator<T, EnforcedDocType, THydratedDocumentType> | AnyArray<SchemaValidator<T, EnforcedDocType, THydratedDocumentType>>;
 
     /** Allows overriding casting logic for this individual path. If a string, the given string overwrites Mongoose's default cast error message. */
     cast?: string |