Merge pull request #5771 from Automattic/4.13

4.13

Author: vkarpov15

docs/middleware.jade

@@ -6,10 +6,10 @@ block content
     Middleware (also called pre and post *hooks*) are functions which are passed
     control during execution of asynchronous functions. Middleware is specified
     on the schema level and is useful for writing [plugins](./plugins.html).
-    Mongoose 4.x has 3 types
-    of middleware: document middleware, model middleware, and query middleware.
+    Mongoose 4.x has 4 types
+    of middleware: document middleware, model middleware, aggregate middleware, and query middleware.
     Document middleware is supported for the following document functions.
-    In document middleware functions, `this` refers to the document. 
+    In document middleware functions, `this` refers to the document.
 
     * [init](./api.html#document_Document-init)
     * [validate](./api.html#document_Document-validate)
@@ -25,10 +25,16 @@ block content
     * [findOneAndRemove](./api.html#query_Query-findOneAndRemove)
     * [findOneAndUpdate](./api.html#query_Query-findOneAndUpdate)
     * [update](./api.html#query_Query-update)
-    
+
+    Aggregate middleware is for `MyModel.aggregate()`. Aggregate middleware
+    executes when you call `exec()` on an aggregate object.
+    In aggregate middleware, `this` refers to the [aggregation object](http://mongoosejs.com/docs/api.html#model_Model.aggregate).
+
+    * [aggregate](http://mongoosejs.com/docs/api.html#model_Model.aggregate)
+
     Model middleware is supported for the following model functions.
     In model middleware functions, `this` refers to the model.
-    
+
     * [insertMany](./api.html#model_Model.insertMany)
 
     All middleware types support pre and post hooks.

lib/aggregate.js

@@ -106,6 +106,41 @@ Aggregate.prototype.append = function() {
   return this;
 };
 
+/**
+ * Appends a new $addFields operator to this aggregate pipeline.
+ * Requires MongoDB v3.4+ to work
+ *
+ * ####Examples:
+  *
+ *     // adding new fields based on existing fields
+ *     aggregate.addFields({
+ *         newField: '$b.nested'
+ *       , plusTen: { $add: ['$val', 10]}
+ *       , sub: {
+ *            name: '$a'
+ *         }
+ *     })
+ *
+ *     // etc
+ *     aggregate.addFields({ salary_k: { $divide: [ "$salary", 1000 ] } });
+ *
+ * @param {Object} arg field specification
+ * @see $addFields https://docs.mongodb.com/manual/reference/operator/aggregation/addFields/
+ * @return {Aggregate}
+ * @api public
+ */
+Aggregate.prototype.addFields = function(arg) {
+  var fields = {};
+  if (typeof arg === 'object' && !util.isArray(arg)) {
+    Object.keys(arg).forEach(function(field) {
+      fields[field] = arg[field];
+    });
+  } else {
+    throw new Error('Invalid addFields() argument. Must be an object');
+  }
+  return this.append({$addFields: fields});
+};
+
 /**
  * Appends a new $project operator to this aggregate pipeline.
  *
@@ -625,26 +660,27 @@ Aggregate.prototype.exec = function(callback) {
     throw new Error('Aggregate not bound to any Model');
   }
   var _this = this;
+  var model = this._model;
   var Promise = PromiseProvider.get();
-  var options = utils.clone(this.options);
+  var options = utils.clone(this.options || {});
+  var pipeline = this._pipeline;
+  var collection = this._model.collection;
 
   if (options && options.cursor) {
     if (options.cursor.async) {
       delete options.cursor.async;
       return new Promise.ES6(function(resolve) {
-        if (!_this._model.collection.buffer) {
+        if (!collection.buffer) {
           process.nextTick(function() {
-            var cursor = _this._model.collection.
-              aggregate(_this._pipeline, options || {});
+            var cursor = collection.aggregate(pipeline, options);
             decorateCursor(cursor);
             resolve(cursor);
             callback && callback(null, cursor);
           });
           return;
         }
-        _this._model.collection.emitter.once('queue', function() {
-          var cursor = _this._model.collection.
-            aggregate(_this._pipeline, options || {});
+        collection.emitter.once('queue', function() {
+          var cursor = collection.aggregate(pipeline, options);
           decorateCursor(cursor);
           resolve(cursor);
           callback && callback(null, cursor);
@@ -654,14 +690,13 @@ Aggregate.prototype.exec = function(callback) {
       delete options.cursor.useMongooseAggCursor;
       return new AggregationCursor(this);
     }
-    var cursor = this._model.collection.
-      aggregate(this._pipeline, this.options || {});
+    var cursor = collection.aggregate(pipeline, options);
     decorateCursor(cursor);
     return cursor;
   }
 
   return new Promise.ES6(function(resolve, reject) {
-    if (!_this._pipeline.length) {
+    if (!pipeline.length) {
       var err = new Error('Aggregate has empty pipeline');
       if (callback) {
         callback(err);
@@ -672,9 +707,20 @@ Aggregate.prototype.exec = function(callback) {
 
     prepareDiscriminatorPipeline(_this);
 
-    _this._model
-        .collection
-        .aggregate(_this._pipeline, _this.options || {}, function(error, result) {
+    model.hooks.execPre('aggregate', _this, function(error) {
+      if (error) {
+        var _opts = { error: error };
+        return model.hooks.execPost('aggregate', _this, [null], _opts, function(error) {
+          if (callback) {
+            callback(error);
+          }
+          reject(error);
+        });
+      }
+
+      collection.aggregate(pipeline, options, function(error, result) {
+        var _opts = { error: error };
+        model.hooks.execPost('aggregate', _this, [result], _opts, function(error, result) {
           if (error) {
             if (callback) {
               callback(error);
@@ -688,6 +734,8 @@ Aggregate.prototype.exec = function(callback) {
           }
           resolve(result);
         });
+      });
+    });
   });
 };
 
@@ -758,6 +806,8 @@ function isOperator(obj) {
  * @param {Aggregate} aggregate Aggregate to prepare
  */
 
+Aggregate._prepareDiscriminatorPipeline = prepareDiscriminatorPipeline;
+
 function prepareDiscriminatorPipeline(aggregate) {
   var schema = aggregate._model.schema,
       discriminatorMapping = schema && schema.discriminatorMapping;
@@ -781,12 +831,11 @@ function prepareDiscriminatorPipeline(aggregate) {
     } else {
       var match = {};
       match[discriminatorKey] = discriminatorValue;
-      aggregate._pipeline = [{$match: match}].concat(originalPipeline);
+      aggregate._pipeline.unshift({ $match: match });
     }
   }
 }
 
-
 /*!
  * Exports
  */

lib/connection.js

@@ -368,6 +368,28 @@ Connection.prototype._openWithoutPromise = function() {
   });
 };
 
+/**
+ * Helper for `createCollection()`. Will explicitly create the given collection
+ * with specified options. Used to create [capped collections](https://docs.mongodb.com/manual/core/capped-collections/)
+ * and [views](https://docs.mongodb.com/manual/core/views/) from mongoose.
+ *
+ * Options are passed down without modification to the [MongoDB driver's `createCollection()` function](http://mongodb.github.io/node-mongodb-native/2.2/api/Db.html#createCollection)
+ *
+ * @param {string} collection The collection to delete
+ * @param {Object} [options] see [MongoDB driver docs](http://mongodb.github.io/node-mongodb-native/2.2/api/Db.html#createCollection)
+ * @param {Function} [callback]
+ * @return {Promise}
+ * @api public
+ */
+
+Connection.prototype.createCollection = _wrapConnHelper(function createCollection(collection, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+  this.db.createCollection(collection, options, cb);
+});
+
 /**
  * Helper for `dropCollection()`. Will delete the given collection, including
  * all documents and indexes.
@@ -403,8 +425,10 @@ 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 cb = arguments.length > 0 ? arguments[arguments.length - 1] : null;
+    var argsWithoutCb = typeof cb === 'function' ?
+      Array.prototype.slice.call(arguments, 0, arguments.length - 1) :
+      Array.prototype.slice.call(arguments);
     var promise = new Promise.ES6(function(resolve, reject) {
       if (_this.readyState !== STATES.connected) {
         _this.on('open', function() {
@@ -782,6 +806,12 @@ Connection.prototype.openUri = function(uri, options, callback) {
       this.user = options.auth.user;
       this.pass = options.auth.password;
     }
+
+    if (options.bufferCommands != null) {
+      options.bufferMaxEntries = 0;
+      this.config.bufferCommands = options.bufferCommands;
+      delete options.bufferCommands;
+    }
   }
 
   this._connectionOptions = options;

lib/cursor/AggregationCursor.js

@@ -14,6 +14,9 @@ var util = require('util');
  * in addition to several other mechanisms for loading documents from MongoDB
  * one at a time.
  *
+ * Creating an AggregationCursor executes the model's pre aggregate hooks,
+ * but **not** the model's post aggregate hooks.
+ *
  * Unless you're an advanced user, do **not** instantiate this class directly.
  * Use [`Aggregate#cursor()`](/docs/api.html#aggregate_Aggregate-cursor) instead.
  *
@@ -47,13 +50,17 @@ util.inherits(AggregationCursor, Readable);
 
 function _init(model, c, agg) {
   if (!model.collection.buffer) {
-    c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
-    c.emit('cursor', c.cursor);
-  } else {
-    model.collection.emitter.once('queue', function() {
+    model.hooks.execPre('aggregate', agg, function() {
       c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
       c.emit('cursor', c.cursor);
     });
+  } else {
+    model.collection.emitter.once('queue', function() {
+      model.hooks.execPre('aggregate', agg, function() {
+        c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
+        c.emit('cursor', c.cursor);
+      });
+    });
   }
 }