mongoose 5.7.4 → 5.7.8

package/History.md

@@ -1,3 +1,43 @@
+5.7.8 / 2019-11-04
+==================
+ * fix(document): allow manually populating path within document array #8273
+ * fix(populate): update top-level `populated()` when updating document array with populated subpaths #8265
+ * fix(cursor): throw error when using aggregation cursor as async iterator #8280
+ * fix(schema): retain `_id: false` in schema after nesting in another schema #8274
+ * fix(document): make Document class an event emitter to support defining documents without models in node #8272
+ * docs: document return types for `.discriminator()` #8287
+ * docs(connection): add note about exporting schemas, not models, in multi connection paradigm #8275
+ * docs: clarify that transforms defined in `toObject()` options are applied to subdocs #8260
+
+5.7.7 / 2019-10-24
+==================
+ * fix(populate): make populate virtual consistently an empty array if local field is only empty arrays #8230
+ * fix(query): allow findOne(objectid) and find(objectid) #8268
+
+5.7.6 / 2019-10-21
+==================
+ * fix: upgrade mongodb driver -> 3.3.3 to fix issue with failing to connect to a replica set if one member is down #8209
+ * fix(document): fix TypeError when setting a single nested subdoc with timestamps #8251
+ * fix(cursor): fix issue with long-running `eachAsync()` cursor #8249 #8235
+ * fix(connection): ensure repeated `close` events from useUnifiedTopology don't disconnect Mongoose from replica set #8224
+ * fix(document): support calling `Document` constructor directly in Node.js #8237
+ * fix(populate): add document array subpaths to parent doc `populated()` when calling `DocumentArray#push()` #8247
+ * fix(options): add missing minlength and maxlength to SchemaStringOptions #8256
+ * docs: add documentarraypath to API docs, including DocumentArrayPath#discriminator() #8164
+ * docs(schematypes): add a section about the `type` property #8227
+ * docs(api): fix Connection.close return param #8258 [gosuhiman](https://github.com/gosuhiman)
+ * docs: update link to broken image on home page #8253 [krosenk729](https://github.com/krosenk729)
+
+5.7.5 / 2019-10-14
+==================
+ * fix(query): delete top-level `_bsontype` property in queries to prevent silent empty queries #8222
+ * fix(update): handle subdocument pre('validate') errors in update validation #7187
+ * fix(subdocument): make subdocument#isModified use parent document's isModified #8223
+ * docs(index): add favicon to home page #8226
+ * docs: add schema options to API docs #8012
+ * docs(middleware): add note about accessing the document being updated in pre('findOneAndUpdate') #8218
+ * refactor: remove redundant code in ValidationError #8244 [AbdelrahmanHafez](https://github.com/AbdelrahmanHafez)
+
 5.7.4 / 2019-10-09
 ==================
  * fix(schema): handle `required: null` and `required: undefined` as `required: false` #8219

package/lib/aggregate.js

@@ -1011,20 +1011,20 @@ Aggregate.prototype.catch = function(reject) {
 
 /**
  * Returns an asyncIterator for use with [`for/await/of` loops](http://bit.ly/async-iterators)
- * This function *only* works for `find()` queries.
  * You do not need to call this function explicitly, the JavaScript runtime
  * will call it for you.
  *
  * ####Example
  *
- *     for await (const doc of Model.find().sort({ name: 1 })) {
+ *     const agg = Model.aggregate([{ $match: { age: { $gte: 25 } } }]);
+ *     for await (const doc of agg) {
  *       console.log(doc.name);
  *     }
  *
  * Node.js 10.x supports async iterators natively without any flags. You can
  * enable async iterators in Node.js 8.x using the [`--harmony_async_iteration` flag](https://github.com/tc39/proposal-async-iteration/issues/117#issuecomment-346695187).
  *
- * **Note:** This function is not if `Symbol.asyncIterator` is undefined. If
+ * **Note:** This function is not set if `Symbol.asyncIterator` is undefined. If
  * `Symbol.asyncIterator` is undefined, that means your Node.js version does not
  * support async iterators.
  *

package/lib/cast.js

@@ -27,6 +27,14 @@ module.exports = function cast(schema, obj, options, context) {
     throw new Error('Query filter must be an object, got an array ', util.inspect(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;
+  }
+
   const paths = Object.keys(obj);
   let i = paths.length;
   let _keys;

package/lib/connection.js

@@ -639,18 +639,28 @@ Connection.prototype.openUri = function(uri, options, callback) {
       _this.db = db;
 
       // `useUnifiedTopology` events
-      if (options.useUnifiedTopology &&
-          get(db, 's.topology.s.description.type') === 'Single') {
-        const server = Array.from(db.s.topology.s.servers.values())[0];
-        server.s.pool.on('reconnect', () => {
-          _handleReconnect();
-        });
-        server.s.pool.on('reconnectFailed', () => {
-          _this.emit('reconnectFailed');
-        });
-        server.s.pool.on('timeout', () => {
-          _this.emit('timeout');
-        });
+      const type = get(db, 's.topology.s.description.type', '');
+      if (options.useUnifiedTopology) {
+        if (type === 'Single') {
+          const server = Array.from(db.s.topology.s.servers.values())[0];
+          server.s.pool.on('reconnect', () => {
+            _handleReconnect();
+          });
+          server.s.pool.on('reconnectFailed', () => {
+            _this.emit('reconnectFailed');
+          });
+          server.s.pool.on('timeout', () => {
+            _this.emit('timeout');
+          });
+        } else if (type.startsWith('ReplicaSet')) {
+          db.on('close', function() {
+            const type = get(db, 's.topology.s.description.type', '');
+            if (type !== 'ReplicaSetWithPrimary') {
+              // Implicitly emits 'disconnected'
+              _this.readyState = STATES.disconnected;
+            }
+          });
+        }
       }
 
       // Backwards compat for mongoose 4.x
@@ -674,10 +684,12 @@ Connection.prototype.openUri = function(uri, options, callback) {
           _this.emit('attemptReconnect');
         });
       }
-      db.on('close', function() {
-        // Implicitly emits 'disconnected'
-        _this.readyState = STATES.disconnected;
-      });
+      if (!options.useUnifiedTopology || !type.startsWith('ReplicaSet')) {
+        db.on('close', function() {
+          // Implicitly emits 'disconnected'
+          _this.readyState = STATES.disconnected;
+        });
+      }
       client.on('left', function() {
         if (_this.readyState === STATES.connected &&
             get(db, 's.topology.s.coreTopology.s.replicaSetState.topologyType') === 'ReplicaSetNoPrimary') {
@@ -745,7 +757,7 @@ const handleUseMongoClient = function handleUseMongoClient(options) {
  *
  * @param {Boolean} [force] optional
  * @param {Function} [callback] optional
- * @return {Connection} self
+ * @return {Promise}
  * @api public
  */
 

package/lib/cursor/AggregationCursor.js

@@ -4,6 +4,7 @@
 
 'use strict';
 
+const MongooseError = require('../error/mongooseError');
 const Readable = require('stream').Readable;
 const eachAsync = require('../helpers/cursor/eachAsync');
 const util = require('util');
@@ -94,6 +95,15 @@ AggregationCursor.prototype._read = function() {
   });
 };
 
+if (Symbol.asyncIterator != null) {
+  const msg = 'Mongoose does not support using async iterators with an ' +
+    'existing aggregation cursor. See http://bit.ly/mongoose-async-iterate-aggregation';
+
+  AggregationCursor.prototype[Symbol.asyncIterator] = function() {
+    throw new MongooseError(msg);
+  };
+}
+
 /**
  * Registers a transform function which subsequently maps documents retrieved
  * via the streams interface or `.next()`

package/lib/document.js

@@ -10,6 +10,7 @@ const MongooseError = require('./error/index');
 const MixedSchema = require('./schema/mixed');
 const ObjectExpectedError = require('./error/objectExpected');
 const ObjectParameterError = require('./error/objectParameter');
+const Schema = require('./schema');
 const StrictModeError = require('./error/strict');
 const ValidatorError = require('./schematype').ValidatorError;
 const VirtualType = require('./virtualtype');
@@ -64,6 +65,17 @@ function Document(obj, fields, skipId, options) {
   }
   options = options || {};
 
+  // Support `browserDocument.js` syntax
+  if (this.schema == null) {
+    const _schema = utils.isObject(fields) && !fields.instanceOfSchema ?
+      new Schema(fields) :
+      fields;
+    this.$__setSchema(_schema);
+    fields = skipId;
+    skipId = options;
+    options = arguments[4] || {};
+  }
+
   this.$__ = new InternalCache;
   this.$__.emitter = new EventEmitter();
   this.isNew = 'isNew' in options ? options.isNew : true;
@@ -172,6 +184,10 @@ utils.each(
 
 Document.prototype.constructor = Document;
 
+for (const i in EventEmitter.prototype) {
+  Document[i] = EventEmitter.prototype[i];
+}
+
 /**
  * The documents schema.
  *
@@ -486,8 +502,7 @@ Document.prototype.$__init = function(doc, opts) {
 
   // handle docs with populated paths
   // If doc._id is not null or undefined
-  if (doc._id !== null && doc._id !== undefined &&
-    opts.populated && opts.populated.length) {
+  if (doc._id != null && opts.populated && opts.populated.length) {
     const id = String(doc._id);
     for (let i = 0; i < opts.populated.length; ++i) {
       const item = opts.populated[i];
@@ -501,6 +516,8 @@ Document.prototype.$__init = function(doc, opts) {
 
   init(this, doc, this._doc, opts);
 
+  markArraySubdocsPopulated(this, opts.populated);
+
   this.emit('init', this);
   this.constructor.emit('init', this);
 
@@ -509,6 +526,44 @@ Document.prototype.$__init = function(doc, opts) {
   return this;
 };
 
+/*!
+ * If populating a path within a document array, make sure each
+ * subdoc within the array knows its subpaths are populated.
+ *
+ * ####Example:
+ *     const doc = await Article.findOne().populate('comments.author');
+ *     doc.comments[0].populated('author'); // Should be set
+ */
+
+function markArraySubdocsPopulated(doc, populated) {
+  if (doc._id == null || populated == null || populated.length === 0) {
+    return;
+  }
+
+  const id = String(doc._id);
+  for (const item of populated) {
+    if (item.isVirtual) {
+      continue;
+    }
+    const path = item.path;
+    const pieces = path.split('.');
+    for (let i = 0; i < pieces.length - 1; ++i) {
+      const subpath = pieces.slice(0, i + 1).join('.');
+      const rest = pieces.slice(i + 1).join('.');
+      const val = doc.get(subpath);
+      if (val == null) {
+        continue;
+      }
+      if (val.isMongooseDocumentArray) {
+        for (let j = 0; j < val.length; ++j) {
+          val[j].populated(rest, item._docs[id][j], item);
+        }
+        break;
+      }
+    }
+  }
+}
+
 /*!
  * Init helper.
  *
@@ -1079,12 +1134,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
     let didPopulate = false;
     if (refMatches && val instanceof Document) {
-      if (this.ownerDocument) {
-        this.ownerDocument().populated(this.$__fullPath(path),
-          val._id, { [populateModelSymbol]: val.constructor });
-      } else {
-        this.populated(path, val._id, { [populateModelSymbol]: val.constructor });
-      }
+      this.populated(path, val._id, { [populateModelSymbol]: val.constructor });
       didPopulate = true;
     }
 
@@ -1117,6 +1167,21 @@ Document.prototype.$set = function $set(path, val, type, options) {
       val = schema.applySetters(val, this, false, priorVal);
     }
 
+    if (schema.$isMongooseDocumentArray &&
+        Array.isArray(val) &&
+        val.length > 0 &&
+        val[0] != null &&
+        val[0].$__ != null &&
+        val[0].$__.populated != null) {
+      const populatedPaths = Object.keys(val[0].$__.populated);
+      for (const populatedPath of populatedPaths) {
+        this.populated(path + '.' + populatedPath,
+          val.map(v => v.populated(populatedPath)),
+          val[0].$__.populated[populatedPath].options);
+      }
+      didPopulate = true;
+    }
+
     if (!didPopulate && this.$__.populated) {
       delete this.$__.populated[path];
     }
@@ -1932,9 +1997,11 @@ Document.prototype.validate = function(options, callback) {
     options = null;
   }
 
-  return utils.promiseOrCallback(callback, cb => this.$__validate(options, function(error) {
-    cb(error);
-  }), this.constructor.events);
+  return utils.promiseOrCallback(callback, cb => {
+    this.$__validate(options, function(error) {
+      cb(error);
+    });
+  }, this.constructor.events);
 };
 
 /*!
@@ -2922,7 +2989,6 @@ Document.prototype.$toObject = function(options, json) {
  *
  * If you want to skip transformations, use `transform: false`:
  *
- *     if (!schema.options.toObject) schema.options.toObject = {};
  *     schema.options.toObject.hide = '_id';
  *     schema.options.toObject.transform = function (doc, ret, options) {
  *       if (options.hide) {
@@ -2938,7 +3004,26 @@ Document.prototype.$toObject = function(options, json) {
  *     doc.toObject({ hide: 'secret _id', transform: false });// { _id: 'anId', secret: 47, name: 'Wreck-it Ralph' }
  *     doc.toObject({ hide: 'secret _id', transform: true }); // { name: 'Wreck-it Ralph' }
  *
- * Transforms are applied _only to the document and are not applied to sub-documents_.
+ * If you pass a transform in `toObject()` options, Mongoose will apply the transform
+ * to [subdocuments](/docs/subdocs.html) in addition to the top-level document.
+ * Similarly, `transform: false` skips transforms for all subdocuments.
+ * Note that this is behavior is different for transforms defined in the schema:
+ * if you define a transform in `schema.options.toObject.transform`, that transform
+ * will **not** apply to subdocuments.
+ *
+ *     const memberSchema = new Schema({ name: String, email: String });
+ *     const groupSchema = new Schema({ members: [memberSchema], name: String, email });
+ *     const Group = mongoose.model('Group', groupSchema);
+ *
+ *     const doc = new Group({
+ *       name: 'Engineering',
+ *       email: 'dev@mongoosejs.io',
+ *       members: [{ name: 'Val', email: 'val@mongoosejs.io' }]
+ *     });
+ *
+ *     // Removes `email` from both top-level document **and** array elements
+ *     // { name: 'Engineering', members: [{ name: 'Val' }] }
+ *     doc.toObject({ transform: (doc, ret) => { delete ret.email; return ret; } });
  *
  * Transforms, like all of these options, are also available for `toJSON`. See [this guide to `JSON.stringify()`](https://thecodebarbarian.com/the-80-20-guide-to-json-stringify-in-javascript.html) to learn why `toJSON()` and `toObject()` are separate functions.
  *

package/lib/error/validation.js

@@ -18,19 +18,21 @@ const util = require('util');
 function ValidationError(instance) {
   this.errors = {};
   this._message = '';
+
+  MongooseError.call(this, this._message);
   if (instance && instance.constructor.name === 'model') {
     this._message = instance.constructor.modelName + ' validation failed';
-    MongooseError.call(this, this._message);
   } else {
     this._message = 'Validation failed';
-    MongooseError.call(this, this._message);
   }
   this.name = 'ValidationError';
+
   if (Error.captureStackTrace) {
     Error.captureStackTrace(this);
   } else {
     this.stack = new Error().stack;
   }
+
   if (instance) {
     instance.errors = this.errors;
   }

package/lib/helpers/cursor/eachAsync.js

@@ -22,6 +22,7 @@ const utils = require('../../utils');
 
 module.exports = function eachAsync(next, fn, options, callback) {
   const parallel = options.parallel || 1;
+  const enqueue = asyncQueue();
 
   const handleNextResult = function(doc, callback) {
     const promise = fn(doc);
@@ -37,71 +38,74 @@ module.exports = function eachAsync(next, fn, options, callback) {
   const iterate = function(callback) {
     let drained = false;
 
-    const getAndRun = function(cb) {
-      _next(function(err, doc) {
-        if (err) return cb(err);
-        if (drained) {
-          return;
-        }
-        if (doc == null) {
-          drained = true;
-          return callback(null);
-        }
-        handleNextResult(doc, function(err) {
-          if (err) return cb(err);
-          // Make sure to clear the stack re: gh-4697
-          setTimeout(function() {
-            getAndRun(cb);
-          }, 0);
-        });
-      });
-    };
-
     let error = null;
     for (let i = 0; i < parallel; ++i) {
-      getAndRun(err => {
-        if (error != null) {
-          return;
+      enqueue(fetch);
+    }
+
+    function fetch(done) {
+      if (drained || error) {
+        return done();
+      }
+
+      next(function(err, doc) {
+        if (drained || error) {
+          return done();
         }
         if (err != null) {
           error = err;
-          return callback(err);
+          callback(err);
+          return done();
+        }
+        if (doc == null) {
+          drained = true;
+          callback(null);
+          return done();
         }
+
+        done();
+
+        handleNextResult(doc, function(err) {
+          if (err != null) {
+            error = err;
+            return callback(err);
+          }
+
+          setTimeout(() => enqueue(fetch), 0);
+        });
       });
     }
   };
 
-  const _nextQueue = [];
   return utils.promiseOrCallback(callback, cb => {
     iterate(cb);
   });
+};
 
-  // `next()` can only execute one at a time, so make sure we always execute
-  // `next()` in series, while still allowing multiple `fn()` instances to run
-  // in parallel.
-  function _next(cb) {
-    if (_nextQueue.length === 0) {
-      return next(_step(cb));
-    }
-    _nextQueue.push(cb);
-  }
+// `next()` can only execute one at a time, so make sure we always execute
+// `next()` in series, while still allowing multiple `fn()` instances to run
+// in parallel.
+function asyncQueue() {
+  const _queue = [];
+  let inProgress = null;
+  let id = 0;
 
-  function _step(cb) {
-    return function(err, doc) {
-      if (err != null) {
-        return cb(err);
-      }
-      cb(null, doc);
+  return function enqueue(fn) {
+    if (_queue.length === 0 && inProgress == null) {
+      inProgress = id++;
+      return fn(_step);
+    }
+    _queue.push(fn);
+  };
 
-      if (doc == null) {
-        return;
+  function _step() {
+    setTimeout(() => {
+      inProgress = null;
+      if (_queue.length > 0) {
+        inProgress = id++;
+        const fn = _queue.shift();
+        fn(_step);
       }
-
-      setTimeout(() => {
-        if (_nextQueue.length > 0) {
-          next(_step(_nextQueue.unshift()));
-        }
-      }, 0);
-    };
+    }, 0);
   }
-};
+}

package/lib/helpers/updateValidators.js

@@ -136,6 +136,9 @@ module.exports = function(query, schema, castedDoc, options, callback) {
                     _err.path = updates[i] + '.' + key;
                     validationErrors.push(_err);
                   }
+                } else {
+                  err.path = updates[i];
+                  validationErrors.push(err);
                 }
               }
               callback(null);

package/lib/index.js

@@ -1015,6 +1015,15 @@ Mongoose.prototype.now = function now() { return new Date(); };
 
 Mongoose.prototype.CastError = require('./error/cast');
 
+/**
+ * The constructor used for schematype options
+ *
+ * @method SchemaTypeOptions
+ * @api public
+ */
+
+Mongoose.prototype.SchemaTypeOptions = require('./options/SchemaTypeOptions');
+
 /**
  * The [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) driver Mongoose uses.
  *

package/lib/model.js

@@ -1066,7 +1066,8 @@ Model.exists = function exists(filter, options, callback) {
  *
  * @param {String} name discriminator model name
  * @param {Schema} schema discriminator model schema
- * @param {String} value the string stored in the `discriminatorKey` property
+ * @param {String} [value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
+ * @return {Model} The newly created discriminator model
  * @api public
  */
 
@@ -1149,7 +1150,7 @@ for (const i in EventEmitter.prototype) {
  *
  * Mongoose calls this function automatically when a model is created using
  * [`mongoose.model()`](/docs/api.html#mongoose_Mongoose-model) or
- * * [`connection.model()`](/docs/api.html#connection_Connection-model), so you
+ * [`connection.model()`](/docs/api.html#connection_Connection-model), so you
  * don't need to call it. This function is also idempotent, so you may call it
  * to get back a promise that will resolve when your indexes are finished
  * building as an alternative to [`MyModel.on('index')`](/docs/guide.html#indexes)
@@ -1963,7 +1964,7 @@ Model.deleteMany = function deleteMany(conditions, options, callback) {
  *     var promise = query.exec();
  *     promise.addBack(function (err, docs) {});
  *
- * @param {Object} filter
+ * @param {Object|ObjectId} filter
  * @param {Object|String} [projection] optional fields to return, see [`Query.prototype.select()`](http://mongoosejs.com/docs/api.html#query_Query-select)
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
  * @param {Function} [callback]
@@ -3411,7 +3412,7 @@ Model.bulkWrite = function(ops, options, callback) {
  *     var mongooseCandy = Candy.hydrate({ _id: '54108337212ffb6d459f854c', type: 'jelly bean' });
  *
  * @param {Object} obj
- * @return {Model} document instance
+ * @return {Document} document instance
  * @api public
  */
 
@@ -4120,10 +4121,11 @@ function populate(model, docs, options, callback) {
     assignmentOpts.excludeId = excludeIdReg.test(select) || (select && select._id === 0);
 
     if (ids.length === 0 || ids.every(utils.isNullOrUndefined)) {
-      // Ensure that we set populate virtuals with count option to 0 even
-      // if we don't actually execute a query.
+      // Ensure that we set populate virtuals to 0 or empty array even
+      // if we don't actually execute a query because they don't have
+      // a value by default. See gh-7731, gh-8230
       --_remaining;
-      if (mod.count) {
+      if (mod.count || mod.isVirtual) {
         _assign(model, [], mod, assignmentOpts);
       }
       continue;

package/lib/options/SchemaArrayOptions.js

@@ -2,6 +2,19 @@
 
 const SchemaTypeOptions = require('./SchemaTypeOptions');
 
+/**
+ * The options defined on an Array schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ tags: [String] });
+ *     schema.path('tags').options; // SchemaArrayOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaArrayOptions
+ */
+
 class SchemaArrayOptions extends SchemaTypeOptions {}
 
 const opts = {

package/lib/options/SchemaBufferOptions.js

@@ -2,6 +2,19 @@
 
 const SchemaTypeOptions = require('./SchemaTypeOptions');
 
+/**
+ * The options defined on a Buffer schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ bitmap: Buffer });
+ *     schema.path('bitmap').options; // SchemaBufferOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaBufferOptions
+ */
+
 class SchemaBufferOptions extends SchemaTypeOptions {}
 
 const opts = {

package/lib/options/SchemaDateOptions.js

@@ -2,6 +2,19 @@
 
 const SchemaTypeOptions = require('./SchemaTypeOptions');
 
+/**
+ * The options defined on a Date schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ startedAt: Date });
+ *     schema.path('startedAt').options; // SchemaDateOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaDateOptions
+ */
+
 class SchemaDateOptions extends SchemaTypeOptions {}
 
 const opts = {