mongoose 4.11.12 → 4.12.1

package/.travis.yml

@@ -17,3 +17,4 @@ before_script:
 script:
   - npm test
   - npm run lint
+  - npm run nsp

package/History.md

@@ -1,3 +1,48 @@
+4.12.1 / 2017-10-08
+===================
+ * fix(document): create new doc when setting single nested, no more set() on copy of priorVal #5693
+ * fix(model): recursively call applyMethods on child schemas for global plugins #5690
+ * docs: fix bad promise lib example on home page #5686
+ * fix(query): handle false when checking for inclusive/exclusive projection #5685
+ * fix(discriminator): allow reusing child schema #5684
+ * fix: make addToSet() on empty array with subdoc trigger manual population #5504
+
+4.12.0 / 2017-10-02
+===================
+ * docs(validation): add docs coverage for ValidatorError.reason #5681
+ * feat(discriminator): always add discriminatorKey to base schema to allow updating #5613
+ * fix(document): make nested docs no longer inherit parent doc's schema props #5586 #5546 #5470
+ * feat(query): run update validators on $pull and $pullAll #5555
+ * feat(query): add .error() helper to query to error out in pre hooks #5520
+ * feat(connection): add dropCollection() helper #5393
+ * feat(schema): add schema-level collation option #5295
+ * feat(types): add `discriminator()` function for single nested subdocs #5244
+ * feat(document): add $isDeleted() getter/setter for better support for soft deletes #4428
+ * feat(connection): bubble up reconnectFailed event when driver gives up reconnecting #4027
+ * fix(query): report error if passing array or other non-object as filter to update query #3677
+ * fix(collection): use createIndex() instead of deprecated ensureIndex() #3280
+
+4.11.14 / 2017-09-30
+====================
+ * chore: add nsp check to the CI build #5679 [hairyhenderson](https://github.com/hairyhenderson)
+ * fix: bump mquery because of security issue with debug package #5677 #5675 [jonathanprl](https://github.com/jonathanprl)
+ * fix(populate): automatically select() populated()-ed fields #5669
+ * fix(connection): make force close work as expected #5664
+ * fix(document): treat $elemMatch as inclusive projection #5661
+ * docs(model/query): clarify which functions fire which middleware #5654
+ * fix(model): make `init()` public and return a promise that resolves when indexes are done building #5563
+
+4.11.13 / 2017-09-24
+====================
+ * fix(query): correctly run replaceOne with update validators #5665 [sime1](https://github.com/sime1)
+ * fix(schema): replace mistype in setupTimestamp method #5656 [zipp3r](https://github.com/zipp3r)
+ * fix(query): avoid throwing cast error for strict: throw with nested id in query #5640
+ * fix(model): ensure class gets combined schema when using class syntax with discriminators #5635
+ * fix(document): handle setting doc array to array of top-level docs #5632
+ * fix(model): handle casting findOneAndUpdate() with overwrite and upsert #5631
+ * fix(update): correctly handle $ in updates #5628
+ * fix(types): handle manual population consistently for unshift() and splice() #5504
+
 4.11.12 / 2017-09-18
 ====================
  * docs(model): asterisk should not render as markdown bullet #5644 [timkinnane](https://github.com/timkinnane)

package/lib/aggregate.js

@@ -63,10 +63,15 @@ function Aggregate() {
 
 Aggregate.prototype.model = function(model) {
   this._model = model;
-  if (this.options.readPreference == null &&
-      model.schema &&
-      model.schema.options.read != null) {
-    this.options.readPreference = model.schema.options.read;
+  if (model.schema != null) {
+    if (this.options.readPreference == null &&
+        model.schema.options.read != null) {
+      this.options.readPreference = model.schema.options.read;
+    }
+    if (this.options.collation == null &&
+        model.schema.options.collation != null) {
+      this.options.collation = model.schema.options.collation;
+    }
   }
   return this;
 };

package/lib/cast.js

@@ -192,7 +192,7 @@ module.exports = function cast(schema, obj, options, context) {
           }
         }
 
-        if (options && options.upsert && options.strict) {
+        if (options && options.upsert && options.strict && !schema.nested[path]) {
           if (options.strict === 'throw') {
             throw new StrictModeError(path);
           }

package/lib/collection.js

@@ -89,8 +89,8 @@ Collection.prototype.onOpen = function() {
  * @api private
  */
 
-Collection.prototype.onClose = function() {
-  if (this.opts.bufferCommands) {
+Collection.prototype.onClose = function(force) {
+  if (this.opts.bufferCommands && !force) {
     this.buffer = true;
   }
 };
@@ -139,6 +139,14 @@ Collection.prototype.ensureIndex = function() {
   throw new Error('Collection#ensureIndex unimplemented by driver');
 };
 
+/**
+ * Abstract method that drivers must implement.
+ */
+
+Collection.prototype.createIndex = function() {
+  throw new Error('Collection#ensureIndex unimplemented by driver');
+};
+
 /**
  * Abstract method that drivers must implement.
  */

package/lib/connection.js

@@ -369,42 +369,70 @@ Connection.prototype._openWithoutPromise = function() {
 };
 
 /**
- * Helper for `dropDatabase()`.
+ * Helper for `dropCollection()`. Will delete the given collection, including
+ * all documents and indexes.
  *
- * @param {Function} callback
+ * @param {string} collection The collection to delete
+ * @param {Function} [callback]
  * @return {Promise}
  * @api public
  */
 
-Connection.prototype.dropDatabase = function(callback) {
-  var Promise = PromiseProvider.get();
-  var _this = this;
-  var promise = new Promise.ES6(function(resolve, reject) {
-    if (_this.readyState !== STATES.connected) {
-      _this.on('open', function() {
-        _this.db.dropDatabase(function(error) {
+Connection.prototype.dropCollection = _wrapConnHelper(function dropCollection(collection, cb) {
+  this.db.dropCollection(collection, cb);
+});
+
+/**
+ * Helper for `dropDatabase()`. Deletes the given database, including all
+ * collections, documents, and indexes.
+ *
+ * @param {Function} [callback]
+ * @return {Promise}
+ * @api public
+ */
+
+Connection.prototype.dropDatabase = _wrapConnHelper(function dropDatabase(cb) {
+  this.db.dropDatabase(cb);
+});
+
+/*!
+ * ignore
+ */
+
+function _wrapConnHelper(fn) {
+  return function() {
+    var _this = this;
+    var Promise = PromiseProvider.get();
+    var argsWithoutCb = Array.prototype.slice.call(arguments, 0, fn.length - 1);
+    var cb = arguments[arguments.length - 1];
+    var promise = new Promise.ES6(function(resolve, reject) {
+      if (_this.readyState !== STATES.connected) {
+        _this.on('open', function() {
+          fn.apply(_this, argsWithoutCb.concat([function(error) {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
+            }
+          }]));
+        });
+      } else {
+        fn.apply(_this, argsWithoutCb.concat([function(error) {
           if (error) {
             reject(error);
           } else {
             resolve();
           }
-        });
-      });
-    } else {
-      _this.db.dropDatabase(function(error) {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
-        }
-      });
+        }]));
+      }
+    });
+    if (cb) {
+      promise.
+        then(function() { cb(); }, function(error) { cb(error); });
     }
-  });
-  if (callback) {
-    promise.then(function() { callback(); }, callback);
-  }
-  return promise;
-};
+    return promise;
+  };
+}
 
 /*!
  * ignore
@@ -769,6 +797,9 @@ Connection.prototype.openUri = function(uri, options, callback) {
         _this.readyState = STATES.connected;
         _this.emit('reconnected');
       });
+      db.s.topology.on('reconnectFailed', function() {
+        _this.emit('reconnectFailed');
+      });
       db.s.topology.on('close', function() {
         // Implicitly emits 'disconnected'
         _this.readyState = STATES.disconnected;
@@ -807,16 +838,25 @@ Connection.prototype.openUri = function(uri, options, callback) {
 /**
  * Closes the connection
  *
+ * @param {Boolean} [force] optional
  * @param {Function} [callback] optional
  * @return {Connection} self
  * @api public
  */
 
-Connection.prototype.close = function(callback) {
+Connection.prototype.close = function(force, callback) {
   var _this = this;
   var Promise = PromiseProvider.get();
+
+  if (typeof force === 'function') {
+    callback = force;
+    force = false;
+  }
+
+  this.$wasForceClosed = !!force;
+
   return new Promise.ES6(function(resolve, reject) {
-    _this._close(function(error) {
+    _this._close(force, function(error) {
       callback && callback(error);
       if (error) {
         reject(error);
@@ -830,10 +870,11 @@ Connection.prototype.close = function(callback) {
 /**
  * Handles closing the connection
  *
+ * @param {Boolean} force
  * @param {Function} callback
  * @api private
  */
-Connection.prototype._close = function(callback) {
+Connection.prototype._close = function(force, callback) {
   var _this = this;
   this._closeCalled = true;
 
@@ -845,11 +886,11 @@ Connection.prototype._close = function(callback) {
     case 1: // connected
     case 4: // unauthorized
       this.readyState = STATES.disconnecting;
-      this.doClose(function(err) {
+      this.doClose(force, function(err) {
         if (err) {
           _this.error(err, callback);
         } else {
-          _this.onClose();
+          _this.onClose(force);
           callback && callback();
         }
       });
@@ -880,18 +921,18 @@ Connection.prototype._close = function(callback) {
  * @api private
  */
 
-Connection.prototype.onClose = function() {
+Connection.prototype.onClose = function(force) {
   this.readyState = STATES.disconnected;
 
   // avoid having the collection subscribe to our event emitter
   // to prevent 0.3 warning
   for (var i in this.collections) {
     if (utils.object.hasOwnProperty(this.collections, i)) {
-      this.collections[i].onClose();
+      this.collections[i].onClose(force);
     }
   }
 
-  this.emit('close');
+  this.emit('close', force);
 };
 
 /**
@@ -906,6 +947,8 @@ Connection.prototype.onClose = function() {
  */
 
 Connection.prototype.collection = function(name, options) {
+  options = options ? utils.clone(options, { retainKeyOrder: true }) : {};
+  options.$wasForceClosed = this.$wasForceClosed;
   if (!(name in this.collections)) {
     this.collections[name] = new Collection(name, this, options);
   }

package/lib/document.js

@@ -41,11 +41,12 @@ var idGetter = require('./plugins/idGetter');
  * @api private
  */
 
-function Document(obj, fields, skipId) {
+function Document(obj, fields, skipId, options) {
   this.$__ = new InternalCache;
   this.$__.emitter = new EventEmitter();
   this.isNew = true;
   this.errors = undefined;
+  this.$__.$options = options || {};
 
   var schema = this.schema;
 
@@ -181,8 +182,12 @@ Document.prototype.$__buildDoc = function(obj, fields, skipId) {
       exclude = !!fields[keys[ki]];
     } else {
       while (ki--) {
-        if (keys[ki] !== '_id' &&
-            (!fields[keys[ki]] || typeof fields[keys[ki]] !== 'object')) {
+        // Does this projection explicitly define inclusion/exclusion?
+        // Explicitly avoid `$meta` and `$slice`
+        var isDefiningProjection = !fields[keys[ki]] ||
+          typeof fields[keys[ki]] !== 'object' ||
+          fields[keys[ki]].$elemMatch != null;
+        if (keys[ki] !== '_id' && isDefiningProjection) {
           exclude = !fields[keys[ki]];
           break;
         }
@@ -495,7 +500,6 @@ Document.prototype.update = function update() {
  */
 
 Document.prototype.set = function(path, val, type, options) {
-  //console.log('set', path, val, this, new Error().stack)
   if (type && utils.getFunctionName(type.constructor) === 'Object') {
     options = type;
     type = undefined;
@@ -754,7 +758,10 @@ Document.prototype.set = function(path, val, type, options) {
       didPopulate = true;
     }
 
-    val = schema.applySetters(val, this, false, priorVal);
+    var setterContext = constructing && this.$__.$options.priorDoc ?
+      this.$__.$options.priorDoc :
+      this;
+    val = schema.applySetters(val, setterContext, false, priorVal);
 
     if (!didPopulate && this.$__.populated) {
       delete this.$__.populated[path];
@@ -1123,6 +1130,33 @@ Document.prototype.$isDefault = function(path) {
   return (path in this.$__.activePaths.states.default);
 };
 
+/**
+ * Getter/setter, determines whether the document was removed or not.
+ *
+ * ####Example:
+ *     product.remove(function (err, product) {
+ *       product.isDeleted(); // true
+ *       product.remove(); // no-op, doesn't send anything to the db
+ *
+ *       product.isDeleted(false);
+ *       product.isDeleted(); // false
+ *       product.remove(); // will execute a remove against the db
+ *     })
+ *
+ * @param {Boolean} [val] optional, overrides whether mongoose thinks the doc is deleted
+ * @return {Boolean} whether mongoose thinks this doc is deleted.
+ * @api public
+ */
+
+Document.prototype.$isDeleted = function(val) {
+  if (arguments.length === 0) {
+    return !!this.$__.isDeleted;
+  }
+
+  this.$__.isDeleted = !!val;
+  return this;
+};
+
 /**
  * Returns true if `path` was directly set and modified, else false.
  *

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

@@ -2,9 +2,10 @@
  * Module dependencies.
  */
 
-var MongooseCollection = require('../../collection'),
-    Collection = require('mongodb').Collection,
-    utils = require('../../utils');
+var MongooseCollection = require('../../collection');
+var Collection = require('mongodb').Collection;
+var util = require('util');
+var utils = require('../../utils');
 
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) collection implementation.
@@ -93,8 +94,8 @@ NativeCollection.prototype.onOpen = function() {
  * @api private
  */
 
-NativeCollection.prototype.onClose = function() {
-  MongooseCollection.prototype.onClose.call(this);
+NativeCollection.prototype.onClose = function(force) {
+  MongooseCollection.prototype.onClose.call(this, force);
 };
 
 /*!
@@ -103,6 +104,10 @@ NativeCollection.prototype.onClose = function() {
 
 function iter(i) {
   NativeCollection.prototype[i] = function() {
+    // If user force closed, queueing will hang forever. See #5664
+    if (this.opts.$wasForceClosed) {
+      return this.conn.db.collection(this.name)[i].apply(collection, args);
+    }
     if (this.buffer) {
       this.addQueue(i, arguments);
       return;
@@ -151,6 +156,13 @@ for (var i in Collection.prototype) {
   iter(i);
 }
 
+/*!
+ * ignore
+ */
+
+Collection.prototype.ensureIndex = util.deprecate(Collection.prototype.ensureIndex,
+  '`ensureIndex()` is deprecated in Mongoose >= 4.12.0, use `createIndex()` instead');
+
 /**
  * Debug print helper
  *

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

@@ -144,7 +144,7 @@ function listen(conn) {
   }
   conn.db._listening = true;
 
-  conn.db.on('close', function() {
+  conn.db.on('close', function(force) {
     if (conn._closeCalled) return;
 
     // the driver never emits an `open` event. auto_reconnect still
@@ -155,7 +155,7 @@ function listen(conn) {
       conn.emit('close');
       return;
     }
-    conn.onClose();
+    conn.onClose(force);
   });
   conn.db.on('error', function(err) {
     conn.emit('error', err);
@@ -224,13 +224,14 @@ NativeConnection.prototype.doOpenSet = function(fn) {
 /**
  * Closes the connection
  *
- * @param {Function} fn
+ * @param {Boolean} [force]
+ * @param {Function} [fn]
  * @return {Connection} this
  * @api private
  */
 
-NativeConnection.prototype.doClose = function(fn) {
-  this.db.close(fn);
+NativeConnection.prototype.doClose = function(force, fn) {
+  this.db.close(force, fn);
   return this;
 };
 

package/lib/error/objectParameter.js

@@ -0,0 +1,36 @@
+/*!
+ * Module dependencies.
+ */
+
+var MongooseError = require('../error.js');
+
+/**
+ * Constructor for errors that happen when a parameter that's expected to be
+ * an object isn't an object
+ *
+ * @param {Any} value
+ * @param {String} paramName
+ * @param {String} fnName
+ * @inherits MongooseError
+ * @api private
+ */
+
+function ObjectParameterError(value, paramName, fnName) {
+  MongooseError.call(this, 'Parameter "' + paramName + '" to ' + fnName +
+    '() must be an object, got ' + value.toString());
+  this.name = 'ObjectParameterError';
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this);
+  } else {
+    this.stack = new Error().stack;
+  }
+}
+
+/*!
+ * Inherits from MongooseError.
+ */
+
+ObjectParameterError.prototype = Object.create(MongooseError.prototype);
+ObjectParameterError.prototype.constructor = MongooseError;
+
+module.exports = ObjectParameterError;