mongoose 5.0.18 → 5.1.0

package/lib/model.js

@@ -11,6 +11,7 @@ var DocumentNotFoundError = require('./error').DocumentNotFoundError;
 var DivergentArrayError = require('./error').DivergentArrayError;
 var Error = require('./error');
 var EventEmitter = require('events').EventEmitter;
+var MongooseMap = require('./types/map');
 var OverwriteModelError = require('./error').OverwriteModelError;
 var PromiseProvider = require('./promise_provider');
 var Query = require('./query');
@@ -129,21 +130,27 @@ Model.prototype.baseModelName;
  */
 
 Model.prototype.$__handleSave = function(options, callback) {
-  var _this = this;
-  var i;
-  var keys;
-  var len;
+  const _this = this;
+  let i;
+  let keys;
+  let len;
   if (!options.safe && this.schema.options.safe) {
     options.safe = this.schema.options.safe;
   }
   if (typeof options.safe === 'boolean') {
     options.safe = null;
   }
-  var safe = options.safe ? utils.clone(options.safe) : options.safe;
+  let safe = options.safe ? utils.clone(options.safe) : options.safe;
+
+  const session = 'session' in options ? options.session : this.$session();
+  if (session != null) {
+    safe = typeof safe === 'object' && safe != null ? safe : {};
+    safe.session = session;
+  }
 
   if (this.isNew) {
     // send entire doc
-    var obj = this.toObject(internalToObjectOptions);
+    const obj = this.toObject(internalToObjectOptions);
 
     if ((obj || {})._id === void 0) {
       // documents must have an _id else mongoose won't know
@@ -158,7 +165,7 @@ Model.prototype.$__handleSave = function(options, callback) {
     }
 
     this.$__version(true, obj);
-    this.collection.insert(obj, safe, function(err, ret) {
+    this.collection.insertOne(obj, safe, function(err, ret) {
       if (err) {
         _this.isNew = true;
         _this.emit('isNew', true);
@@ -181,7 +188,7 @@ Model.prototype.$__handleSave = function(options, callback) {
     // since it already exists
     this.$__.inserting = false;
 
-    var delta = this.$__delta();
+    const delta = this.$__delta();
 
     if (delta) {
       if (delta instanceof Error) {
@@ -189,7 +196,7 @@ Model.prototype.$__handleSave = function(options, callback) {
         return;
       }
 
-      var where = this.$__where(delta[0]);
+      const where = this.$__where(delta[0]);
       if (where instanceof Error) {
         callback(where);
         return;
@@ -203,7 +210,7 @@ Model.prototype.$__handleSave = function(options, callback) {
         }
       }
 
-      this.collection.update(where, delta[1], safe, function(err, ret) {
+      this.collection.updateOne(where, delta[1], safe, function(err, ret) {
         if (err) {
           callback(err);
           return;
@@ -257,16 +264,17 @@ Model.prototype.$__save = function(options, callback) {
         let doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
         this.$__.version = undefined;
 
+        let key = this.schema.options.versionKey;
+        let version = this.getValue(key) || 0;
+
         if (numAffected <= 0) {
           // the update failed. pass an error back
-          let err = new VersionError(this);
+          let err = new VersionError(this, version);
           return callback(err);
         }
 
         // increment version if was successful
         if (doIncrement) {
-          let key = this.schema.options.versionKey;
-          let version = this.getValue(key) | 0;
           this.setValue(key, version + 1);
         }
       }
@@ -321,7 +329,9 @@ Model.prototype.save = function(options, fn) {
     options = undefined;
   }
 
-  if (!options) {
+  if (options != null) {
+    options = utils.clone(options);
+  } else {
     options = {};
   }
 
@@ -1068,8 +1078,8 @@ function _ensureIndexes(model, options, callback) {
     var index = indexes.shift();
     if (!index) return done();
 
-    var indexFields = index[0];
-    var indexOptions = index[1];
+    var indexFields = utils.clone(index[0]);
+    var indexOptions = utils.clone(index[1]);
     _handleSafe(options);
 
     indexSingleStart(indexFields, options);
@@ -1847,6 +1857,126 @@ Model.findByIdAndUpdate = function(id, update, options, callback) {
   return this.findOneAndUpdate.call(this, {_id: id}, update, options, callback);
 };
 
+/**
+ * Issue a MongoDB `findOneAndDelete()` command.
+ *
+ * Finds a matching document, removes it, and passes the found document
+ * (if any) to the callback.
+ *
+ * Executes immediately if `callback` is passed else a Query object is returned.
+ *
+ * This function triggers the following middleware.
+ *
+ * - `findOneAndDelete()`
+ *
+ * This function differs slightly from `Model.findOneAndRemove()` in that
+ * `findOneAndRemove()` becomes a [MongoDB `findAndModify()` command](https://docs.mongodb.com/manual/reference/method/db.collection.findAndModify/),
+ * as opposed to a `findOneAndDelete()` command. For most mongoose use cases,
+ * this distinction is purely pedantic. You should use `findOneAndDelete()`
+ * unless you have a good reason not to.
+ *
+ * ####Options:
+ *
+ * - `sort`: if multiple docs are found by the conditions, sets the sort order to choose which doc to update
+ * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
+ * - `select`: sets the document fields to return
+ * - `rawResult`: if true, returns the [raw result from the MongoDB driver](http://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html#findAndModify)
+ * - `strict`: overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict) for this update
+ *
+ * ####Examples:
+ *
+ *     A.findOneAndDelete(conditions, options, callback) // executes
+ *     A.findOneAndDelete(conditions, options)  // return Query
+ *     A.findOneAndDelete(conditions, callback) // executes
+ *     A.findOneAndDelete(conditions) // returns Query
+ *     A.findOneAndDelete()           // returns Query
+ *
+ * Values are cast to their appropriate types when using the findAndModify helpers.
+ * However, the below are not executed by default.
+ *
+ * - defaults. Use the `setDefaultsOnInsert` option to override.
+ *
+ * `findAndModify` helpers support limited validation. You can
+ * enable these by setting the `runValidators` options,
+ * respectively.
+ *
+ * If you need full-fledged validation, use the traditional approach of first
+ * retrieving the document.
+ *
+ *     Model.findById(id, function (err, doc) {
+ *       if (err) ..
+ *       doc.name = 'jason bourne';
+ *       doc.save(callback);
+ *     });
+ *
+ * @param {Object} conditions
+ * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
+ * @param {Function} [callback]
+ * @return {Query}
+ * @api public
+ */
+
+Model.findOneAndDelete = function(conditions, options, callback) {
+  if (arguments.length === 1 && typeof conditions === 'function') {
+    var msg = 'Model.findOneAndDelete(): First argument must not be a function.\n\n'
+        + '  ' + this.modelName + '.findOneAndDelete(conditions, callback)\n'
+        + '  ' + this.modelName + '.findOneAndDelete(conditions)\n'
+        + '  ' + this.modelName + '.findOneAndDelete()\n';
+    throw new TypeError(msg);
+  }
+
+  if (typeof options === 'function') {
+    callback = options;
+    options = undefined;
+  }
+  if (callback) {
+    callback = this.$wrapCallback(callback);
+  }
+
+  var fields;
+  if (options) {
+    fields = options.select;
+    options.select = undefined;
+  }
+
+  var mq = new this.Query({}, {}, this, this.collection);
+  mq.select(fields);
+
+  return mq.findOneAndDelete(conditions, options, callback);
+};
+
+/**
+ * Issue a MongoDB `findOneAndDelete()` command by a document's _id field.
+ * In other words, `findByIdAndDelete(id)` is a shorthand for
+ * `findOneAndDelete({ _id: id })`.
+ *
+ * This function triggers the following middleware.
+ *
+ * - `findOneAndDelete()`
+ *
+ * @param {Object|Number|String} id value of `_id` to query by
+ * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
+ * @param {Function} [callback]
+ * @return {Query}
+ * @see Model.findOneAndRemove #model_Model.findOneAndRemove
+ * @see mongodb http://www.mongodb.org/display/DOCS/findAndModify+Command
+ */
+
+Model.findByIdAndDelete = function(id, options, callback) {
+  if (arguments.length === 1 && typeof id === 'function') {
+    var msg = 'Model.findByIdAndDelete(): First argument must not be a function.\n\n'
+        + '  ' + this.modelName + '.findByIdAndDelete(id, callback)\n'
+        + '  ' + this.modelName + '.findByIdAndDelete(id)\n'
+        + '  ' + this.modelName + '.findByIdAndDelete()\n';
+    throw new TypeError(msg);
+  }
+  if (callback) {
+    callback = this.$wrapCallback(callback);
+  }
+
+  return this.findOneAndDelete({_id: id}, options, callback);
+};
+
 /**
  * Issue a mongodb findAndModify remove command.
  *
@@ -2125,6 +2255,41 @@ Model.watch = function(pipeline, options) {
   return new ChangeStream(this, pipeline, options);
 };
 
+/**
+ * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
+ * for benefits like causal consistency and [retryable writes](https://docs.mongodb.com/manual/core/retryable-writes/).
+ *
+ * This function does not trigger any middleware.
+ *
+ * ####Example:
+ *
+ *     const session = await Person.startSession();
+ *     let doc = await Person.findOne({ name: 'Ned Stark' }, { session });
+ *     await doc.remove();
+ *     // `doc` will always be null, even if reading from a replica set
+ *     // secondary. Without causal consistency, it is possible to
+ *     // get a doc back from the below query if the query reads from a
+ *     // secondary that is experiencing replication lag.
+ *     doc = await Person.findOne({ name: 'Ned Stark' }, { readPreference: 'secondary' });
+ *
+ * @param {Object} [options] see the [mongodb driver options](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html#startSession)
+ * @param {Boolean} [options.causalConsistency=true] set to false to disable causal consistency
+ * @param {Function} [callback]
+ * @return {Promise<ClientSession>} promise that resolves to a MongoDB driver `ClientSession`
+ * @api public
+ */
+
+Model.startSession = function(options, callback) {
+  return utils.promiseOrCallback(callback, cb => {
+    if (this.collection.buffer) {
+      return this.collection.addQueue(() => {
+        cb(null, this.db.client.startSession(options));
+      });
+    }
+    return cb(null, this.db.client.startSession(options));
+  });
+};
+
 /**
  * Shortcut for validating an array of documents and inserting them into
  * MongoDB if they're all valid. This function is faster than `.create()`
@@ -3051,6 +3216,7 @@ function populate(model, docs, options, callback) {
   }
 
   modelsMap = getModelsMapForPopulate(model, docs, options);
+
   if (modelsMap instanceof Error) {
     return utils.immediate(function() {
       callback(modelsMap);
@@ -3266,9 +3432,9 @@ function assignVals(o) {
     return valueFilter(val, options, o.justOne);
   }
 
-  for (var i = 0; i < docs.length; ++i) {
-    if (utils.getValue(o.path, docs[i]) == null &&
-      !getVirtual(o.originalModel.schema, o.path)) {
+  for (let i = 0; i < docs.length; ++i) {
+    const existingVal = utils.getValue(o.path, docs[i]);
+    if (existingVal == null && !getVirtual(o.originalModel.schema, o.path)) {
       continue;
     }
 
@@ -3282,6 +3448,23 @@ function assignVals(o) {
       rawIds[i] = rawIds[i][0];
     }
 
+
+    // If we're populating a map, the existing value will be an object, so
+    // we need to transform again
+    const isMap = docs[i].constructor.name === 'model' ?
+      existingVal instanceof Map :
+      existingVal != null && existingVal.constructor.name === 'Object';
+    if (!o.isVirtual && isMap) {
+      const _keys = existingVal instanceof Map ?
+        Array.from(existingVal.keys()) :
+        Object.keys(existingVal);
+      rawIds[i] = rawIds[i].reduce((cur, v, i) => {
+        // Avoid casting because that causes infinite recursion
+        cur.$init(_keys[i], v);
+        return cur;
+      }, new MongooseMap({}, docs[i]));
+    }
+
     if (o.isVirtual && docs[i].constructor.name === 'model') {
       // If virtual populate and doc is already init-ed, need to walk through
       // the actual doc to set rather than setting `_doc` directly
@@ -3298,6 +3481,7 @@ function assignVals(o) {
       if (docs[i].$__) {
         docs[i].populated(o.path, o.allIds[i], o.allOptions);
       }
+
       utils.setValue(o.path, rawIds[i], docs[i], setValue, false);
     }
   }
@@ -3481,6 +3665,7 @@ function getModelsMapForPopulate(model, docs, options) {
     if (typeof foreignField === 'function') {
       foreignField = foreignField.call(doc);
     }
+
     const ret = convertTo_id(utils.getValue(localField, doc));
     const id = String(utils.getValue(foreignField, doc));
     options._docs[id] = Array.isArray(ret) ? ret.slice() : ret;
@@ -3543,6 +3728,9 @@ function getModelsMapForPopulate(model, docs, options) {
     if (schema && schema.caster) {
       schema = schema.caster;
     }
+    if (schema && schema.$isSchemaMap) {
+      schema = schema.$__schemaType;
+    }
 
     if (!schema && model.discriminators) {
       discriminatorKey = model.schema.discriminatorMapping.key;
@@ -3631,7 +3819,7 @@ function convertTo_id(val) {
   if (val instanceof Model) return val._id;
 
   if (Array.isArray(val)) {
-    for (var i = 0; i < val.length; ++i) {
+    for (let i = 0; i < val.length; ++i) {
       if (val[i] instanceof Model) {
         val[i] = val[i]._id;
       }
@@ -3643,6 +3831,21 @@ function convertTo_id(val) {
     return [].concat(val);
   }
 
+  // `populate('map')` may be an object if populating on a doc that hasn't
+  // been hydrated yet
+  if (val != null && val.constructor.name === 'Object') {
+    const ret = [];
+    for (const key of Object.keys(val)) {
+      ret.push(val[key]);
+    }
+    return ret;
+  }
+  // If doc has already been hydrated, e.g. `doc.populate('map').execPopulate()`
+  // then `val` will already be a map
+  if (val instanceof Map) {
+    return Array.from(val.values());
+  }
+
   return val;
 }
 
@@ -3874,24 +4077,24 @@ function applyQueryMiddleware(Query, model) {
     nullResultByDefault: true
   };
 
-  Query.prototype._count = model.hooks.createWrapper('count',
-    Query.prototype._count, null, kareemOptions);
+  // `update()` thunk has a different name because `_update` was already taken
   Query.prototype._execUpdate = model.hooks.createWrapper('update',
     Query.prototype._execUpdate, null, kareemOptions);
-  Query.prototype._find = model.hooks.createWrapper('find',
-    Query.prototype._find, null, kareemOptions);
-  Query.prototype._findOne = model.hooks.createWrapper('findOne',
-    Query.prototype._findOne, null, kareemOptions);
-  Query.prototype._findOneAndRemove = model.hooks.createWrapper('findOneAndRemove',
-    Query.prototype._findOneAndRemove, null, kareemOptions);
-  Query.prototype._findOneAndUpdate = model.hooks.createWrapper('findOneAndUpdate',
-    Query.prototype._findOneAndUpdate, null, kareemOptions);
-  Query.prototype._replaceOne = model.hooks.createWrapper('replaceOne',
-    Query.prototype._replaceOne, null, kareemOptions);
-  Query.prototype._updateMany = model.hooks.createWrapper('updateMany',
-    Query.prototype._updateMany, null, kareemOptions);
-  Query.prototype._updateOne = model.hooks.createWrapper('updateOne',
-    Query.prototype._updateOne, null, kareemOptions);
+
+  [
+    'count',
+    'find',
+    'findOne',
+    'findOneAndDelete',
+    'findOneAndRemove',
+    'findOneAndUpdate',
+    'replaceOne',
+    'updateMany',
+    'updateOne'
+  ].forEach(fn => {
+    Query.prototype[`_${fn}`] = model.hooks.createWrapper(fn,
+      Query.prototype[`_${fn}`], null, kareemOptions);
+  });
 }
 
 /*!

package/lib/plugins/saveSubdocs.js

@@ -23,7 +23,7 @@ module.exports = function(schema) {
     }
 
     each(subdocs, function(subdoc, cb) {
-      subdoc.save(function(err) {
+      subdoc.save({ suppressWarning: true }, function(err) {
         cb(err);
       });
     }, function(error) {