mongoose 5.0.6 → 5.0.10

package/History.md

@@ -1,3 +1,44 @@
+5.0.10 / 2018-03-12
+===================
+ * docs(schematype): add notes re: running setters on queries #6209
+ * docs: fix typo #6208 [kamagatos](https://github.com/kamagatos)
+ * fix(query): only call setters once on query filter props for findOneAndUpdate and findOneAndRemove #6203
+ * docs: elaborate on connection string changes in migration guide #6193
+ * fix(document): skip applyDefaults if subdoc is null #6187
+ * docs: fix schematypes docs and link to them #6176
+ * docs(faq): add FAQs re: array defaults and casting aggregation pipelines #6184 #6176 #6170 [lineus](https://github.com/lineus)
+ * fix(document): ensure primitive defaults are set and built-in default functions run before setters #6155
+ * fix(query): handle single embedded embedded discriminators in castForQuery #6027
+
+5.0.9 / 2018-03-05
+==================
+ * perf: bump mongodb -> 3.0.4 to fix SSL perf issue #6065
+
+5.0.8 / 2018-03-03
+==================
+ * docs: remove obsolete references to `emitIndexErrors` #6186 [isaackwan](https://github.com/isaackwan)
+ * fix(query): don't cast findOne() until exec() so setters don't run twice #6157
+ * fix: remove document_provider.web.js file #6186
+ * fix(discriminator): support custom discriminator model names #6100 [wentout](https://github.com/wentout)
+ * fix: support caching calls to `useDb()` #6036 [rocketspacer](https://github.com/rocketspacer)
+ * fix(query): add omitUndefined option so setDefaultsOnInsert can kick in on undefined #6034
+ * fix: upgrade mongodb -> 3.0.3 for reconnectTries: 0 blocking process exit fix #6028
+
+5.0.7 / 2018-02-23
+==================
+ * fix: support eachAsync options with aggregation cursor #6169 #6168 [vichle](https://github.com/vichle)
+ * docs: fix link to MongoDB compound indexes docs #6162 [br0p0p](https://github.com/br0p0p)
+ * docs(aggregate): use eachAsync instead of incorrect `each()` #6160 [simllll](https://github.com/simllll)
+ * chore: fix benchmarks #6158 [pradel](https://github.com/pradel)
+ * docs: remove dead link to old blog post #6154 [markstos](https://github.com/markstos)
+ * fix: don't convert dates to numbers when updating mixed path #6146 #6145 [s4rbagamble](https://github.com/s4rbagamble)
+ * feat(aggregate): add replaceRoot, count, sortByCount helpers #6142 [jakesjews](https://github.com/jakesjews)
+ * fix(document): add includedChildren flag to modifiedPaths() #6134
+ * perf: don't create wrapper function if no hooks specified #6126
+ * fix(schema): allow indexes on single nested subdocs for geoJSON #6113
+ * fix(document): allow depopulating all fields #6073
+ * feat(mongoose): add support for `useFindAndModify` option on singleton #5616
+
 5.0.6 / 2018-02-15
 ==================
  * refactor(query.castUpdate): avoid creating error until necessary #6137

package/README.md

@@ -10,6 +10,8 @@ Mongoose is a [MongoDB](https://www.mongodb.org/) object modeling tool designed
 
 [mongoosejs.com](http://mongoosejs.com/)
 
+[Mongoose 5.0.0](https://github.com/Automattic/mongoose/blob/master/History.md#500--2018-01-17) was released on January 17, 2018. You can find more details on backwards breaking changes in 5.0.0 on [GitHub](https://github.com/Automattic/mongoose/blob/master/migrating_to_5.md).
+
 ## Support
 
   - [Stack Overflow](http://stackoverflow.com/questions/tagged/mongoose)
@@ -57,7 +59,7 @@ First, we need to define a connection. If your app uses only one database, you s
 Both `connect` and `createConnection` take a `mongodb://` URI, or the parameters `host, database, port, options`.
 
 ```js
-var mongoose = require('mongoose');
+const mongoose = require('mongoose');
 
 mongoose.connect('mongodb://localhost/my_database');
 ```
@@ -73,14 +75,14 @@ Once connected, the `open` event is fired on the `Connection` instance. If you'r
 Models are defined through the `Schema` interface.
 
 ```js
-var Schema = mongoose.Schema,
+const Schema = mongoose.Schema,
     ObjectId = Schema.ObjectId;
 
-var BlogPost = new Schema({
-    author    : ObjectId,
-    title     : String,
-    body      : String,
-    date      : Date
+const BlogPost = new Schema({
+ author: ObjectId,
+ title: String,
+ body: String,
+ date: Date
 });
 ```
 
@@ -100,7 +102,7 @@ Aside from defining the structure of your documents and the types of data you're
 The following example shows some of these features:
 
 ```js
-var Comment = new Schema({
+const Comment = new Schema({
   name: { type: String, default: 'hahaha' },
   age: { type: Number, min: 18, index: true },
   bio: { type: String, match: /[a-z]/ },
@@ -127,19 +129,19 @@ Take a look at the example in `examples/schema.js` for an end-to-end example of
 Once we define a model through `mongoose.model('ModelName', mySchema)`, we can access it through the same function
 
 ```js
-var myModel = mongoose.model('ModelName');
+const myModel = mongoose.model('ModelName');
 ```
 
 Or just do it all at once
 
 ```js
-var MyModel = mongoose.model('ModelName', mySchema);
+const MyModel = mongoose.model('ModelName', mySchema);
 ```
 
 The first argument is the _singular_ name of the collection your model is for. **Mongoose automatically looks for the _plural_ version of your model name.** For example, if you use
 
 ```js
-var MyModel = mongoose.model('Ticket', mySchema);
+const MyModel = mongoose.model('Ticket', mySchema);
 ```
 
 Then Mongoose will create the model for your __tickets__ collection, not your __ticket__ collection.
@@ -147,7 +149,7 @@ Then Mongoose will create the model for your __tickets__ collection, not your __
 Once we have our model, we can then instantiate it, and save it:
 
 ```js
-var instance = new MyModel();
+const instance = new MyModel();
 instance.my.key = 'hello';
 instance.save(function (err) {
   //
@@ -167,18 +169,18 @@ You can also `findOne`, `findById`, `update`, etc. For more details check out [t
 **Important!** If you opened a separate connection using `mongoose.createConnection()` but attempt to access the model through `mongoose.model('ModelName')` it will not work as expected since it is not hooked up to an active db connection. In this case access your model through the connection you created:
 
 ```js
-var conn = mongoose.createConnection('your connection string'),
-    MyModel = conn.model('ModelName', schema),
-    m = new MyModel;
+const conn = mongoose.createConnection('your connection string');
+const MyModel = conn.model('ModelName', schema);
+const m = new MyModel;
 m.save(); // works
 ```
 
 vs
 
 ```js
-var conn = mongoose.createConnection('your connection string'),
-    MyModel = mongoose.model('ModelName', schema),
-    m = new MyModel;
+const conn = mongoose.createConnection('your connection string');
+const MyModel = mongoose.model('ModelName', schema);
+const m = new MyModel;
 m.save(); // does not work b/c the default connection object was never connected
 ```
 

package/browser.js

@@ -0,0 +1,6 @@
+/**
+ * Export lib/mongoose
+ *
+ */
+
+module.exports = require('./lib/browser');

package/lib/aggregate.js

@@ -339,6 +339,78 @@ Aggregate.prototype.unwind = function() {
   return this.append.apply(this, res);
 };
 
+/**
+ * Appends a new $replaceRoot operator to this aggregate pipeline.
+ *
+ * Note that the `$replaceRoot` operator requires the new root to start with '$'.
+ * Mongoose will prepend '$' if the specified field doesn't start '$'.
+ *
+ * ####Examples:
+ *
+ *     aggregate.replaceRoot("user");
+ *
+ * @see $replaceRoot https://docs.mongodb.org/manual/reference/operator/aggregation/replaceRoot
+ * @param {String} the field which will become the new root document
+ * @return {Aggregate}
+ * @api public
+ */
+
+Aggregate.prototype.replaceRoot = function(newRoot) {
+  return this.append({
+    $replaceRoot: {
+      newRoot: (newRoot && newRoot.charAt(0) === '$') ? newRoot : '$' + newRoot
+    }
+  });
+};
+
+/**
+ * Appends a new $count operator to this aggregate pipeline.
+ *
+ * ####Examples:
+ *
+ *     aggregate.count("userCount");
+ *
+ * @see $count https://docs.mongodb.org/manual/reference/operator/aggregation/count
+ * @param {String} the name of the count field
+ * @return {Aggregate}
+ * @api public
+ */
+
+Aggregate.prototype.count = function(countName) {
+  return this.append({ $count: countName });
+};
+
+/**
+ * Appends a new $sortByCount operator to this aggregate pipeline. Accepts either a string field name
+ * or a pipeline object.
+ *
+ * Note that the `$sortByCount` operator requires the new root to start with '$'.
+ * Mongoose will prepend '$' if the specified field name doesn't start with '$'.
+ *
+ * ####Examples:
+ *
+ *     aggregate.sortByCount('users');
+ *     aggregate.sortByCount({ $mergeObjects: [ "$employee", "$business" ] })
+ *
+ * @see $sortByCount https://docs.mongodb.com/manual/reference/operator/aggregation/sortByCount/
+ * @param {Object|String} arg
+ * @return {Aggregate} this
+ * @api public
+ */
+
+Aggregate.prototype.sortByCount = function(arg) {
+  if (arg && typeof arg === 'object') {
+    return this.append({ $sortByCount: arg });
+  } else if (typeof arg === 'string') {
+    return this.append({
+      $sortByCount: (arg && arg.charAt(0) === '$') ? arg : '$' + arg
+    });
+  } else {
+    throw new TypeError('Invalid arg "' + arg + '" to sortByCount(), ' +
+      'must be string or object');
+  }
+};
+
 /**
  * Appends new custom $lookup operator(s) to this aggregate pipeline.
  *

package/lib/cast.js

@@ -1,13 +1,16 @@
+'use strict';
+
 /*!
  * Module dependencies.
  */
 
-var StrictModeError = require('./error/strict');
-var Types = require('./schema/index');
-var util = require('util');
-var utils = require('./utils');
+const StrictModeError = require('./error/strict');
+const Types = require('./schema/index');
+const get = require('lodash.get');
+const util = require('util');
+const utils = require('./utils');
 
-var ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
+const ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
 
 /**
  * Handles internal casting for query filters.
@@ -67,6 +70,31 @@ module.exports = function cast(schema, obj, options, context) {
 
       schematype = schema.path(path);
 
+      // Check for embedded discriminator paths
+      if (!schematype) {
+        let split = path.split('.');
+        let j = split.length;
+        while (j--) {
+          let pathFirstHalf = split.slice(0, j).join('.');
+          let pathLastHalf = split.slice(j).join('.');
+          let _schematype = schema.path(pathFirstHalf);
+          let discriminatorKey = get(_schematype, 'schema.options.discriminatorKey');
+          // gh-6027: if we haven't found the schematype but this path is
+          // underneath an embedded discriminator and the embedded discriminator
+          // key is in the query, use the embedded discriminator schema
+          if (_schematype != null &&
+              get(_schematype, 'schema.discriminators') != null &&
+              discriminatorKey != null &&
+              pathLastHalf !== discriminatorKey) {
+            const discriminatorVal = get(obj, pathFirstHalf + '.' + discriminatorKey);
+            if (discriminatorVal) {
+              schematype = _schematype.schema.discriminators[discriminatorVal].
+                path(pathLastHalf);
+            }
+          }
+        }
+      }
+
       if (!schematype) {
         // Handle potential embedded array queries
         var split = path.split('.'),
@@ -206,7 +234,7 @@ module.exports = function cast(schema, obj, options, context) {
         } else if (options.strictQuery) {
           delete obj[path];
         }
-      } else if (val === null || val === undefined) {
+      } else if (val == null) {
         obj[path] = null;
         continue;
       } else if (val.constructor.name === 'Object') {

package/lib/collection.js

@@ -161,6 +161,22 @@ Collection.prototype.findAndModify = function() {
   throw new Error('Collection#findAndModify unimplemented by driver');
 };
 
+/**
+ * Abstract method that drivers must implement.
+ */
+
+Collection.prototype.findOneAndUpdate = function() {
+  throw new Error('Collection#findOneAndUpdate unimplemented by driver');
+};
+
+/**
+ * Abstract method that drivers must implement.
+ */
+
+Collection.prototype.findOneAndDelete = function() {
+  throw new Error('Collection#findOneAndDelete unimplemented by driver');
+};
+
 /**
  * Abstract method that drivers must implement.
  */

package/lib/connection.js

@@ -59,7 +59,8 @@ function Connection(base) {
   this.pass = null;
   this.name = null;
   this.options = null;
-  this.otherDbs = [];
+  this.otherDbs = []; // FIXME: To be replaced with relatedDbs
+  this.relatedDbs = {}; // Hashmap of other dbs that share underlying connection
   this.states = STATES;
   this._readyState = STATES.disconnected;
   this._closeCalled = false;
@@ -103,11 +104,16 @@ Object.defineProperty(Connection.prototype, 'readyState', {
 
     if (this._readyState !== val) {
       this._readyState = val;
-      // loop over the otherDbs on this connection and change their state
+      // [legacy] loop over the otherDbs on this connection and change their state
       for (var i = 0; i < this.otherDbs.length; i++) {
         this.otherDbs[i].readyState = val;
       }
 
+      // loop over relatedDbs on this connection and change their state
+      for (var k in this.relatedDbs) {
+        this.relatedDbs[k].readyState = val;
+      }
+
       if (STATES.connected === val) {
         this._hasOpened = true;
       }

package/lib/cursor/AggregationCursor.js

@@ -3,6 +3,7 @@
  */
 
 var Readable = require('stream').Readable;
+var eachAsync = require('../services/cursor/eachAsync');
 var util = require('util');
 var utils = require('../utils');
 
@@ -10,7 +11,7 @@ var utils = require('../utils');
  * An AggregationCursor is a concurrency primitive for processing aggregation
  * results one document at a time. It is analogous to QueryCursor.
  *
- * An AggregationCursor fulfills the [Node.js streams3 API](https://strongloop.com/strongblog/whats-new-io-js-beta-streams3/),
+ * An AggregationCursor fulfills the Node.js streams3 API,
  * in addition to several other mechanisms for loading documents from MongoDB
  * one at a time.
  *
@@ -184,52 +185,23 @@ AggregationCursor.prototype.next = function(callback) {
  * Returns a promise that resolves when done.
  *
  * @param {Function} fn
+ * @param {Object} [options]
+ * @param {Number} [options.parallel] the number of promises to execute in parallel. Defaults to 1.
  * @param {Function} [callback] executed when all docs have been processed
  * @return {Promise}
  * @api public
  * @method eachAsync
  */
 
-AggregationCursor.prototype.eachAsync = function(fn, callback) {
-  var handleNextResult = function(doc, callback) {
-    var promise = fn(doc);
-    if (promise && typeof promise.then === 'function') {
-      promise.then(
-        function() { callback(null); },
-        function(error) { callback(error); });
-    } else {
-      callback(null);
-    }
-  };
-
-  var iterate = callback => {
-    return _next(this, function(error, doc) {
-      if (error) {
-        return callback(error);
-      }
-      if (!doc) {
-        return callback(null);
-      }
-      handleNextResult(doc, function(error) {
-        if (error) {
-          return callback(error);
-        }
-        // Make sure to clear the stack re: gh-4697
-        setTimeout(function() {
-          iterate(callback);
-        }, 0);
-      });
-    });
-  };
+AggregationCursor.prototype.eachAsync = function(fn, opts, callback) {
+  var _this = this;
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  opts = opts || {};
 
-  return utils.promiseOrCallback(callback, cb => {
-    iterate(function(error) {
-      if (error) {
-        return cb(error);
-      }
-      cb(null);
-    });
-  });
+  return eachAsync(function(cb) { return _next(_this, cb); }, fn, opts, callback);
 };
 
 /**

package/lib/cursor/QueryCursor.js

@@ -10,7 +10,7 @@ var utils = require('../utils');
 
 /**
  * A QueryCursor is a concurrency primitive for processing query results
- * one document at a time. A QueryCursor fulfills the [Node.js streams3 API](https://strongloop.com/strongblog/whats-new-io-js-beta-streams3/),
+ * one document at a time. A QueryCursor fulfills the Node.js streams3 API,
  * in addition to several other mechanisms for loading documents from MongoDB
  * one at a time.
  *

package/lib/document.js

@@ -87,6 +87,10 @@ function Document(obj, fields, skipId, options) {
 
   this.$__buildDoc(obj, fields, skipId, exclude, hasIncludedChildren);
 
+  // By default, defaults get applied **before** setting initial values
+  // Re: gh-6155
+  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, true);
+
   if (obj) {
     if (obj instanceof Document) {
       this.isNew = obj.isNew;
@@ -99,7 +103,10 @@ function Document(obj, fields, skipId, options) {
     }
   }
 
-  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren);
+  // Function defaults get applied **after** setting initial values so they
+  // see the full doc rather than an empty one, unless they opt out.
+  // Re: gh-3781, gh-6155
+  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, false);
 
   this.$__._id = this._id;
 
@@ -202,7 +209,7 @@ function $__hasIncludedChildren(fields) {
  * ignore
  */
 
-function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren) {
+function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren, isBeforeSetters) {
   const paths = Object.keys(doc.schema.paths);
   const plen = paths.length;
 
@@ -222,6 +229,10 @@ function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren) {
     let doc_ = doc._doc;
 
     for (let j = 0; j < len; ++j) {
+      if (doc_ == null) {
+        break;
+      }
+
       let piece = path[j];
       curPath += (!curPath.length ? '' : '.') + piece;
 
@@ -242,6 +253,18 @@ function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren) {
           break;
         }
 
+        if (typeof type.defaultValue === 'function') {
+          if (!type.defaultValue.$runBeforeSetters && isBeforeSetters) {
+            break;
+          }
+          if (type.defaultValue.$runBeforeSetters && !isBeforeSetters) {
+            break;
+          }
+        } else if (!isBeforeSetters) {
+          // Non-function defaults should always run **before** setters
+          continue;
+        }
+
         if (fields && exclude !== null) {
           if (exclude === true) {
             // apply defaults to all non-excluded fields
@@ -1111,19 +1134,43 @@ Document.prototype.$ignore = function(path) {
 /**
  * Returns the list of paths that have been modified.
  *
+ * @param {Object} [options]
+ * @param {Boolean} [options.includeChildren=false] if true, returns children of modified paths as well. For example, if false, the list of modified paths for `doc.colors = { primary: 'blue' };` will **not** contain `colors.primary`
  * @return {Array}
  * @api public
  */
 
-Document.prototype.modifiedPaths = function() {
+Document.prototype.modifiedPaths = function(options) {
+  options = options || {};
   var directModifiedPaths = Object.keys(this.$__.activePaths.states.modify);
+  var _this = this;
   return directModifiedPaths.reduce(function(list, path) {
     var parts = path.split('.');
-    return list.concat(parts.reduce(function(chains, part, i) {
+    list = list.concat(parts.reduce(function(chains, part, i) {
       return chains.concat(parts.slice(0, i).concat(part).join('.'));
     }, []).filter(function(chain) {
       return (list.indexOf(chain) === -1);
     }));
+
+    if (!options.includeChildren) {
+      return list;
+    }
+
+    var cur = _this.get(path);
+    if (cur != null && typeof cur === 'object') {
+      if (cur._doc) {
+        cur = cur._doc;
+      }
+      Object.keys(cur).
+        filter(function(key) {
+          return list.indexOf(path + '.' + key) === -1;
+        }).
+        forEach(function(key) {
+          list.push(path + '.' + key);
+        });
+    }
+
+    return list;
   }, []);
 };
 
@@ -1497,8 +1544,8 @@ function _getPathsToValidate(doc) {
  */
 
 Document.prototype.$__validate = function(callback) {
-  var _this = this;
-  var _complete = function() {
+  const _this = this;
+  const _complete = function() {
     var err = _this.$__.validationError;
     _this.$__.validationError = undefined;
     _this.emit('validate', _this);
@@ -1516,11 +1563,11 @@ Document.prototype.$__validate = function(callback) {
   };
 
   // only validate required fields when necessary
-  var paths = _getPathsToValidate(this);
+  const paths = _getPathsToValidate(this);
 
   if (paths.length === 0) {
     return process.nextTick(function() {
-      var error = _complete();
+      const error = _complete();
       if (error) {
         return _this.schema.s.hooks.execPost('validate:error', _this, [ _this], { error: error }, function(error) {
           callback(error);
@@ -1530,11 +1577,11 @@ Document.prototype.$__validate = function(callback) {
     });
   }
 
-  var validated = {};
-  var total = 0;
+  const validated = {};
+  let total = 0;
 
   var complete = function() {
-    var error = _complete();
+    const error = _complete();
     if (error) {
       return _this.schema.s.hooks.execPost('validate:error', _this, [ _this], { error: error }, function(error) {
         callback(error);
@@ -1552,7 +1599,7 @@ Document.prototype.$__validate = function(callback) {
     total++;
 
     process.nextTick(function() {
-      var p = _this.schema.path(path);
+      const p = _this.schema.path(path);
       if (!p) {
         return --total || complete();
       }
@@ -1563,10 +1610,11 @@ Document.prototype.$__validate = function(callback) {
         return;
       }
 
-      var val = _this.getValue(path);
-      var scope = path in _this.$__.pathsToScopes ?
+      const val = _this.getValue(path);
+      const scope = path in _this.$__.pathsToScopes ?
         _this.$__.pathsToScopes[path] :
         _this;
+
       p.doValidate(val, function(err) {
         if (err) {
           _this.invalidate(path, err, undefined, true);
@@ -1576,8 +1624,8 @@ Document.prototype.$__validate = function(callback) {
     });
   };
 
-  var numPaths = paths.length;
-  for (var i = 0; i < numPaths; ++i) {
+  const numPaths = paths.length;
+  for (let i = 0; i < numPaths; ++i) {
     validatePath(paths[i]);
   }
 };
@@ -2647,8 +2695,26 @@ Document.prototype.depopulate = function(path) {
   if (typeof path === 'string') {
     path = path.split(' ');
   }
-  for (var i = 0; i < path.length; i++) {
-    var populatedIds = this.populated(path[i]);
+  var i;
+  var populatedIds;
+
+  if (arguments.length === 0) {
+    // Depopulate all
+    var keys = Object.keys(this.$__.populated);
+
+    for (i = 0; i < keys.length; i++) {
+      populatedIds = this.populated(keys[i]);
+      if (!populatedIds) {
+        continue;
+      }
+      delete this.$__.populated[keys[i]];
+      this.$set(keys[i], populatedIds);
+    }
+    return this;
+  }
+
+  for (i = 0; i < path.length; i++) {
+    populatedIds = this.populated(path[i]);
     if (!populatedIds) {
       continue;
     }

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

@@ -40,7 +40,10 @@ NativeConnection.prototype.__proto__ = MongooseConnection.prototype;
  * @api public
  */
 
-NativeConnection.prototype.useDb = function(name) {
+NativeConnection.prototype.useDb = function(name, options) {
+  // Return immediately if cached
+  if (options && options.useCache && this.relatedDbs[name]) return this.relatedDbs[name];
+
   // we have to manually copy all of the attributes...
   var newConn = new this.constructor();
   newConn.name = name;
@@ -88,6 +91,12 @@ NativeConnection.prototype.useDb = function(name) {
   this.otherDbs.push(newConn);
   newConn.otherDbs.push(this);
 
+  // push onto the relatedDbs cache, this is used when state changes
+  if (options && options.useCache) {
+    this.relatedDbs[newConn.name] = newConn;
+    newConn.relatedDbs = this.relatedDbs;
+  }
+
   return newConn;
 };