mongoose 5.4.3 → 5.4.4

package/History.md

@@ -1,3 +1,10 @@
+5.4.4 / 2019-01-14
+==================
+ * fix(query): run casting on arrayFilters option #7079
+ * fix(document): support skipping timestamps on save() with `save({ timestamps: false })` #7357
+ * fix(model): apply custom where on `Document#remove()` so we attach the shardKey #7393
+ * docs(mongoose): document `mongoose.connections` #7338
+
 5.4.3 / 2019-01-09
 ==================
  * fix(populate): handle `count` option when using `Document#populate()` on a virtual #7380

package/lib/cast.js

@@ -337,4 +337,4 @@ function _cast(val, numbertype, context) {
       }
     }
   }
-}
+}

package/lib/helpers/query/castFilterPath.js

@@ -0,0 +1,54 @@
+'use strict';
+
+module.exports = function castFilterPath(query, schematype, val) {
+  const any$conditionals = Object.keys(val).some(function(k) {
+    return k.charAt(0) === '$' && k !== '$id' && k !== '$ref';
+  });
+
+  if (!any$conditionals) {
+    return schematype.castForQueryWrapper({
+      val: val,
+      context: query
+    });
+  }
+
+  const ks = Object.keys(val);
+
+  let k = ks.length;
+
+  while (k--) {
+    const $cond = ks[k];
+    const nested = val[$cond];
+
+    if ($cond === '$not') {
+      if (nested && schematype && !schematype.caster) {
+        const _keys = Object.keys(nested);
+        if (_keys.length && _keys[0].charAt(0) === '$') {
+          for (const key in nested) {
+            nested[key] = schematype.castForQueryWrapper({
+              $conditional: key,
+              val: nested[key],
+              context: context
+            });
+          }
+        } else {
+          val[$cond] = schematype.castForQueryWrapper({
+            $conditional: $cond,
+            val: nested,
+            context: context
+          });
+        }
+        continue;
+      }
+      // cast(schematype.caster ? schematype.caster.schema : schema, nested, options, context);
+    } else {
+      val[$cond] = schematype.castForQueryWrapper({
+        $conditional: $cond,
+        val: nested,
+        context: context
+      });
+    }
+  }
+
+  return val;
+};

package/lib/helpers/update/castArrayFilters.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const castFilterPath = require('../query/castFilterPath');
+const modifiedPaths = require('./modifiedPaths');
+
+module.exports = function castArrayFilters(query) {
+  const arrayFilters = query.options.arrayFilters;
+  if (!Array.isArray(arrayFilters)) {
+    return;
+  }
+
+  const update = query.getUpdate();
+  const schema = query.schema;
+
+  const updatedPaths = modifiedPaths(update);
+
+  const updatedPathsByFilter = Object.keys(updatedPaths).reduce((cur, path) => {
+    const matches = path.match(/\$\[[^\]]+\]/g);
+    if (matches == null) {
+      return cur;
+    }
+    for (const match of matches) {
+      const firstMatch = path.indexOf(match);
+      if (firstMatch !== path.lastIndexOf(match)) {
+        throw new Error(`Path '${path}' contains the same array filter multiple times`);
+      }
+      cur[match.substring(2, match.length - 1)] = path.substr(0, firstMatch - 1);
+    }
+    return cur;
+  }, {});
+
+  for (const filter of arrayFilters) {
+    if (filter == null) {
+      throw new Error(`Got null array filter in ${arrayFilters}`);
+    }
+    const firstKey = Object.keys(filter)[0];
+
+    if (filter[firstKey] == null) {
+      continue;
+    }
+
+    const dot = firstKey.indexOf('.');
+    let filterPath = dot === -1 ?
+      updatedPathsByFilter[firstKey] + '.0' :
+      updatedPathsByFilter[firstKey.substr(0, dot)] + '.0' + firstKey.substr(dot);
+
+    if (filterPath == null) {
+      throw new Error(`Filter path not found for ${firstKey}`);
+    }
+
+    // If there are multiple array filters in the path being updated, make sure
+    // to replace them so we can get the schema path.
+    filterPath = filterPath.replace(/\$\[[^\]]+\]/g, '0');
+
+    const schematype = schema.path(filterPath);
+    if (typeof filter[firstKey] === 'object') {
+      filter[firstKey] = castFilterPath(query, schematype, filter[firstKey]);
+    } else {
+      filter[firstKey] = schematype.castForQuery(filter[firstKey]);
+    }
+  }
+};

package/lib/index.js

@@ -586,7 +586,7 @@ Mongoose.prototype.plugin = function(fn, opts) {
 };
 
 /**
- * The default connection of the mongoose module.
+ * The Mongoose module's default connection. Equivalent to `mongoose.connections][0]`, see [`connections`](#mongoose_Mongoose-connections).
  *
  * ####Example:
  *
@@ -596,10 +596,11 @@ Mongoose.prototype.plugin = function(fn, opts) {
  *
  * This is the connection used by default for every model created using [mongoose.model](#index_Mongoose-model).
  *
+ * To create a new connection, use [`createConnection()`](#mongoose_Mongoose-createConnection).
+ *
  * @memberOf Mongoose
  * @instance
- * @property connection
- * @return {Connection}
+ * @property {Connection} connection
  * @api public
  */
 
@@ -614,6 +615,29 @@ Mongoose.prototype.__defineSetter__('connection', function(v) {
   }
 });
 
+/**
+ * An array containing all [connections](connections.html) associated with this
+ * Mongoose instance. By default, there is 1 connection. Calling
+ * [`createConnection()`](#mongoose_Mongoose-createConnection) adds a connection
+ * to this array.
+ *
+ * ####Example:
+ *
+ *     const mongoose = require('mongoose');
+ *     mongoose.connections.length; // 1, just the default connection
+ *     mongoose.connections[0] === mongoose.connection; // true
+ *
+ *     mongoose.createConnection('mongodb://localhost:27017/test');
+ *     mongoose.connections.length; // 2
+ *
+ * @memberOf Mongoose
+ * @instance
+ * @property {Array} connections
+ * @api public
+ */
+
+Mongoose.prototype.connections;
+
 /*!
  * Driver dependent APIs
  */

package/lib/model.js

@@ -171,13 +171,12 @@ Model.prototype.baseModelName;
  *     MyModel.events.on('error', err => console.log(err.message));
  *
  *     // Prints a 'CastError' because of the above handler
- *     await MyModel.findOne({ _id: 'notanid' }).catch({} => {});
+ *     await MyModel.findOne({ _id: 'notanid' }).catch(noop);
  *
  * @api public
  * @fires error whenever any query or model function errors
- * @property events
  * @memberOf Model
- * @static
+ * @static events
  */
 
 Model.events;
@@ -193,15 +192,28 @@ Model.events;
 
 Model._middleware;
 
+/*!
+ * ignore
+ */
+
+function _applyCustomWhere(doc, where) {
+  if (doc.$where == null) {
+    return;
+  }
+
+  const keys = Object.keys(doc.$where);
+  const len = keys.length;
+  for (let i = 0; i < len; ++i) {
+    where[keys[i]] = doc.$where[keys[i]];
+  }
+}
+
 /*!
  * ignore
  */
 
 Model.prototype.$__handleSave = function(options, callback) {
   const _this = this;
-  let i;
-  let keys;
-  let len;
   let saveOptions = {};
 
   if ('safe' in options) {
@@ -285,13 +297,7 @@ Model.prototype.$__handleSave = function(options, callback) {
         return;
       }
 
-      if (this.$where) {
-        keys = Object.keys(this.$where);
-        len = keys.length;
-        for (i = 0; i < len; ++i) {
-          where[keys[i]] = this.$where[keys[i]];
-        }
-      }
+      _applyCustomWhere(this, where);
 
       this[modelCollectionSymbol].updateOne(where, delta[1], saveOptions, function(err, ret) {
         if (err) {
@@ -420,6 +426,7 @@ function generateVersionError(doc, modifiedPaths) {
  * @param {Boolean} [options.j] set to true for MongoDB to wait until this `save()` has been [journaled before resolving the returned promise](https://docs.mongodb.com/manual/reference/write-concern/#j-option). Overrides the [schema-level `writeConcern` option](/docs/guide.html#writeConcern)
  * @param {Number} [options.wtimeout] sets a [timeout for the write concern](https://docs.mongodb.com/manual/reference/write-concern/#wtimeout). Overrides the [schema-level `writeConcern` option](/docs/guide.html#writeConcern).
  * @param {Boolean} [options.checkKeys=true] the MongoDB driver prevents you from saving keys that start with '$' or contain '.' by default. Set this option to `false` to skip that check. See [restrictions on field names](https://docs.mongodb.com/manual/reference/limits/#Restrictions-on-Field-Names)
+ * @param {Boolean} [options.timestamps=true] if `false` and [timestamps](./guide.html#timestamps) are enabled, skip timestamps for this `save()`.
  * @param {Function} [fn] optional callback
  * @return {Promise|undefined} Returns undefined if used with callback or a Promise otherwise.
  * @api public
@@ -458,8 +465,11 @@ Model.prototype.save = function(options, fn) {
       return cb(parallelSave);
     }
 
+    this.$__.saveOptions = options;
+
     this.$__save(options, error => {
       this.$__.saving = undefined;
+      delete this.$__.saveOptions;
 
       if (error) {
         this.$__handleReject(error);
@@ -915,6 +925,8 @@ Model.prototype.$__remove = function $__remove(options, cb) {
     return cb(where);
   }
 
+  _applyCustomWhere(this, where);
+
   this[modelCollectionSymbol].deleteOne(where, options, err => {
     if (!err) {
       this.$__.isDeleted = true;

package/lib/plugins/sharding.js

@@ -16,6 +16,10 @@ module.exports = function shardingPlugin(schema) {
     applyWhere.call(this);
     next();
   });
+  schema.pre('remove', function(next) {
+    applyWhere.call(this);
+    next();
+  });
   schema.post('save', function() {
     storeShard.call(this);
   });

package/lib/query.js

@@ -11,6 +11,7 @@ const QueryCursor = require('./cursor/QueryCursor');
 const ReadPreference = require('./driver').get().ReadPreference;
 const applyWriteConcern = require('./helpers/schema/applyWriteConcern');
 const cast = require('./cast');
+const castArrayFilters = require('./helpers/update/castArrayFilters');
 const castUpdate = require('./helpers/query/castUpdate');
 const completeMany = require('./helpers/query/completeMany');
 const get = require('./helpers/get');
@@ -1728,6 +1729,18 @@ Query.prototype._castConditions = function() {
   }
 };
 
+/*!
+ * ignore
+ */
+
+function _castArrayFilters(query) {
+  try {
+    castArrayFilters(query);
+  } catch (err) {
+    query.error(err);
+  }
+}
+
 /**
  * Thunk around find()
  *
@@ -3147,6 +3160,8 @@ Query.prototype._findAndModify = function(type, callback) {
     return callback(castedQuery);
   }
 
+  _castArrayFilters(this);
+
   const opts = this._optionsForExec(model);
 
   if ('strict' in opts) {
@@ -3385,6 +3400,8 @@ function _updateThunk(op, callback) {
 
   this._castConditions();
 
+  _castArrayFilters(this);
+
   if (this.error() != null) {
     callback(this.error());
     return null;

package/lib/schema.js

@@ -918,6 +918,10 @@ Schema.prototype.setupTimestamp = function(timestamps) {
   this.add(schemaAdditions);
 
   this.pre('save', function(next) {
+    if (get(this, '$__.saveOptions.timestamps') === false) {
+      return next();
+    }
+
     const defaultTimestamp = (this.ownerDocument ? this.ownerDocument() : this).
       constructor.base.now();
     const auto_id = this._id && this._id.auto;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.4.3",
+  "version": "5.4.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",