mongoose 5.5.3 → 5.5.4

package/History.md

@@ -1,3 +1,15 @@
+5.5.4 / 2019-04-25
+==================
+ * fix(document): avoid calling custom getters when saving #7719
+ * fix(timestamps): handle child schema timestamps correctly when reusing child schemas #7712
+ * fix(query): pass correct callback for _legacyFindAndModify #7736 [Fonger](https://github.com/Fonger)
+ * fix(model+query): allow setting `replacement` parameter for `findOneAndReplace()` #7654
+ * fix(map): make `delete()` unset the key in the database #7746 [Fonger](https://github.com/Fonger)
+ * fix(array): use symbol for `_schema` property to avoid confusing deep equality checks #7700
+ * fix(document): prevent `depopulate()` from removing fields with empty array #7741 #7740 [Fonger](https://github.com/Fonger)
+ * fix: make `MongooseArray#includes` support ObjectIds #7732 #6354 [Fonger](https://github.com/Fonger)
+ * fix(document): report correct validation error index when pushing onto doc array #7744 [Fonger](https://github.com/Fonger)
+
 5.5.3 / 2019-04-22
 ==================
  * fix: add findAndModify deprecation warning that references the useFindAndModify option #7644

package/lib/document.js

@@ -2547,22 +2547,22 @@ Document.prototype.$__getAllSubdocs = function() {
   Embedded = Embedded || require('./types/embedded');
 
   function docReducer(doc, seed, path) {
-    const val = path ? doc[path] : doc;
+    let val = doc;
+    if (path) {
+      val = doc instanceof Document ? doc._doc[path] : doc[path];
+    }
     if (val instanceof Embedded) {
       seed.push(val);
-    }
-    else if (val instanceof Map) {
+    } else if (val instanceof Map) {
       seed = Array.from(val.keys()).reduce(function(seed, path) {
         return docReducer(val.get(path), seed, null);
       }, seed);
-    }
-    else if (val && val.$isSingleNested) {
+    } else if (val && val.$isSingleNested) {
       seed = Object.keys(val._doc).reduce(function(seed, path) {
         return docReducer(val._doc, seed, path);
       }, seed);
       seed.push(val);
-    }
-    else if (val && val.isMongooseDocumentArray) {
+    } else if (val && val.isMongooseDocumentArray) {
       val.forEach(function _docReduce(doc) {
         if (!doc || !doc._doc) {
           return;
@@ -3339,7 +3339,7 @@ Document.prototype.depopulate = function(path) {
     if (virtualKeys.indexOf(path[i]) !== -1) {
       delete this.$$populatedVirtuals[path[i]];
       delete this._doc[path[i]];
-    } else {
+    } else if (populatedIds) {
       this.$set(path[i], populatedIds);
     }
   }

package/lib/helpers/schema/setParentPointers.js

@@ -9,19 +9,19 @@ const hasParentPointers = Symbol('Mongoose.helpers.setParentPointers');
  * This is a slow path function, should only run when model is compiled
  */
 
-module.exports = function setParentPointers(schema) {
+module.exports = function setParentPointers(schema, parentSchemaType) {
   if (schema[hasParentPointers]) {
     return;
   }
   schema[hasParentPointers] = true;
   for (const path of Object.keys(schema.paths)) {
     const schemaType = schema.paths[path];
-    if (schemaType.schema != null) {
-      Object.defineProperty(schemaType.schema, '$schemaType', {
+    if (parentSchemaType != null) {
+      Object.defineProperty(schemaType, '$parentSchemaType', {
         configurable: true,
         writable: false,
         enumerable: false,
-        value: schemaType
+        value: parentSchemaType
       });
     }
     Object.defineProperty(schemaType, '$parentSchema', {
@@ -35,7 +35,7 @@ module.exports = function setParentPointers(schema) {
   for (const path of Object.keys(schema.paths)) {
     const type = schema.paths[path];
     if (type.$isSingleNested || type.$isMongooseDocumentArray) {
-      setParentPointers(type.schema, false);
+      setParentPointers(type.schema, type);
     }
   }
 };

package/lib/helpers/symbols.js

@@ -1,9 +1,10 @@
 'use strict';
 
 exports.arrayParentSymbol = Symbol('mongoose#Array#_parent');
-exports.documentArrayParent = Symbol.for('mongoose:documentArrayParent');
-exports.getSymbol = Symbol.for('mongoose#Document#get');
-exports.modelSymbol = Symbol.for('mongoose#Model');
-exports.objectIdSymbol = Symbol.for('mongoose#ObjectId');
-exports.schemaTypeSymbol = Symbol.for('mongoose#schemaType');
-exports.validatorErrorSymbol = Symbol.for('mongoose:validatorError');
+exports.arraySchemaSymbol = Symbol('mongoose#Array#_schema');
+exports.documentArrayParent = Symbol('mongoose:documentArrayParent');
+exports.getSymbol = Symbol('mongoose#Document#get');
+exports.modelSymbol = Symbol('mongoose#Model');
+exports.objectIdSymbol = Symbol('mongoose#ObjectId');
+exports.schemaTypeSymbol = Symbol('mongoose#schemaType');
+exports.validatorErrorSymbol = Symbol('mongoose:validatorError');

package/lib/helpers/update/applyTimestampsToChildren.js

@@ -63,18 +63,24 @@ function applyTimestampsToChildren(now, update, schema) {
         if (!path) {
           continue;
         }
+
+        let parentSchemaType = null;
+        const pieces = keyToSearch.split('.');
+        for (let i = pieces.length - 1; i > 0; --i) {
+          const s = schema.path(pieces.slice(0, i).join('.'));
+          if (s != null &&
+              (s.$isMongooseDocumentArray || s.$isSingleNested)) {
+            parentSchemaType = s;
+            break;
+          }
+        }
+
         if (Array.isArray(update.$set[key]) && path.$isMongooseDocumentArray) {
           applyTimestampsToDocumentArray(update.$set[key], path, now);
         } else if (update.$set[key] && path.$isSingleNested) {
           applyTimestampsToSingleNested(update.$set[key], path, now);
-        } else if (path.$parentSchema !== schema && path.$parentSchema != null) {
-          const parentPath = path.$parentSchema.$schemaType;
-
-          if (parentPath == null) {
-            continue;
-          }
-
-          timestamps = parentPath.schema.options.timestamps;
+        } else if (parentSchemaType != null) {
+          timestamps = parentSchemaType.schema.options.timestamps;
           createdAt = handleTimestampOption(timestamps, 'createdAt');
           updatedAt = handleTimestampOption(timestamps, 'updatedAt');
 
@@ -82,23 +88,23 @@ function applyTimestampsToChildren(now, update, schema) {
             continue;
           }
 
-          if (parentPath.$isSingleNested) {
+          if (parentSchemaType.$isSingleNested) {
             // Single nested is easy
-            update.$set[parentPath.path + '.' + updatedAt] = now;
+            update.$set[parentSchemaType.path + '.' + updatedAt] = now;
             continue;
           }
 
-          let childPath = key.substr(parentPath.path.length + 1);
-          const firstDot = childPath.indexOf('.');
+          let childPath = key.substr(parentSchemaType.path.length + 1);
 
-          // Shouldn't happen, but if it does ignore this path
-          if (firstDot === -1) {
+          if (/^\d+$/.test(childPath)) {
+            update.$set[parentSchemaType.path + '.' + childPath][updatedAt] = now;
             continue;
           }
 
-          childPath = childPath.substr(0, firstDot);
+          const firstDot = childPath.indexOf('.');
+          childPath = firstDot !== -1 ? childPath.substr(0, firstDot) : childPath;
 
-          update.$set[parentPath.path + '.' + childPath + '.' + updatedAt] = now;
+          update.$set[parentSchemaType.path + '.' + childPath + '.' + updatedAt] = now;
         } else if (path.schema != null && path.schema != schema && update.$set[key]) {
           timestamps = path.schema.options.timestamps;
           createdAt = handleTimestampOption(timestamps, 'createdAt');

package/lib/model.js

@@ -2603,7 +2603,8 @@ Model.findByIdAndDelete = function(id, options, callback) {
  *
  * - defaults. Use the `setDefaultsOnInsert` option to override.
  *
- * @param {Object} conditions
+ * @param {Object} filter Replace the first document that matches this filter
+ * @param {Object} [replacement] Replace with this document
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](http://mongoosejs.com/docs/api.html#query_Query-setOptions)
  * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](http://mongoosejs.com/docs/api.html#query_Query-lean).
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
@@ -2613,18 +2614,24 @@ Model.findByIdAndDelete = function(id, options, callback) {
  * @api public
  */
 
-Model.findOneAndReplace = function(conditions, options, callback) {
-  if (arguments.length === 1 && typeof conditions === 'function') {
-    const 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';
+Model.findOneAndReplace = function(filter, replacement, options, callback) {
+  if (arguments.length === 1 && typeof filter === 'function') {
+    const msg = 'Model.findOneAndReplace(): First argument must not be a function.\n\n'
+        + '  ' + this.modelName + '.findOneAndReplace(conditions, callback)\n'
+        + '  ' + this.modelName + '.findOneAndReplace(conditions)\n'
+        + '  ' + this.modelName + '.findOneAndReplace()\n';
     throw new TypeError(msg);
   }
 
-  if (typeof options === 'function') {
+  if (arguments.length === 3 && typeof options === 'function') {
     callback = options;
-    options = undefined;
+    options = replacement;
+    replacement = void 0;
+  }
+  if (arguments.length === 2 && typeof replacement === 'function') {
+    callback = replacement;
+    replacement = void 0;
+    options = void 0;
   }
   if (callback) {
     callback = this.$wrapCallback(callback);
@@ -2639,7 +2646,7 @@ Model.findOneAndReplace = function(conditions, options, callback) {
   const mq = new this.Query({}, {}, this, this.collection);
   mq.select(fields);
 
-  return mq.findOneAndReplace(conditions, options, callback);
+  return mq.findOneAndReplace(filter, replacement, options, callback);
 };
 
 /**
@@ -4486,8 +4493,8 @@ function convertTo_id(val) {
         val[i] = val[i]._id;
       }
     }
-    if (val.isMongooseArray && val._schema) {
-      return val._schema.cast(val, val.$parent());
+    if (val.isMongooseArray && val.$schema()) {
+      return val.$schema().cast(val, val.$parent());
     }
 
     return [].concat(val);

package/lib/query.js

@@ -3118,16 +3118,17 @@ Query.prototype._findOneAndDelete = wrapThunk(function(callback) {
  *
  * ####Examples
  *
- *     A.where().findOneAndReplace(conditions, options, callback) // executes
- *     A.where().findOneAndReplace(conditions, options)  // return Query
- *     A.where().findOneAndReplace(conditions, callback) // executes
- *     A.where().findOneAndReplace(conditions) // returns Query
- *     A.where().findOneAndReplace(callback)   // executes
- *     A.where().findOneAndReplace()           // returns Query
+ *     A.where().findOneAndReplace(filter, replacement, options, callback); // executes
+ *     A.where().findOneAndReplace(filter, replacement, options); // return Query
+ *     A.where().findOneAndReplace(filter, replacement, callback); // executes
+ *     A.where().findOneAndReplace(filter); // returns Query
+ *     A.where().findOneAndReplace(callback); // executes
+ *     A.where().findOneAndReplace(); // returns Query
  *
  * @method findOneAndReplace
  * @memberOf Query
- * @param {Object} [conditions]
+ * @param {Object} [filter]
+ * @param {Object} [replacement]
  * @param {Object} [options]
  * @param {Boolean} [options.rawResult] if true, returns the [raw result from the MongoDB driver](http://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html#findAndModify)
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
@@ -3138,28 +3139,39 @@ Query.prototype._findOneAndDelete = wrapThunk(function(callback) {
  * @api public
  */
 
-Query.prototype.findOneAndReplace = function(conditions, options, callback) {
+Query.prototype.findOneAndReplace = function(filter, replacement, options, callback) {
   this.op = 'findOneAndReplace';
   this._validate();
 
   switch (arguments.length) {
-    case 2:
+    case 3:
       if (typeof options === 'function') {
         callback = options;
-        options = {};
+        options = void 0;
+      }
+      break;
+    case 2:
+      if (typeof replacement === 'function') {
+        callback = replacement;
+        replacement = void 0;
       }
       break;
     case 1:
-      if (typeof conditions === 'function') {
-        callback = conditions;
-        conditions = undefined;
-        options = undefined;
+      if (typeof filter === 'function') {
+        callback = filter;
+        filter = void 0;
+        replacement = void 0;
+        options = void 0;
       }
       break;
   }
 
-  if (mquery.canMerge(conditions)) {
-    this.merge(conditions);
+  if (mquery.canMerge(filter)) {
+    this.merge(filter);
+  }
+
+  if (replacement != null) {
+    this._mergeUpdate(replacement);
   }
 
   options && this.setOptions(options);
@@ -3419,7 +3431,7 @@ Query.prototype._findAndModify = function(type, callback) {
       if (error) {
         return callback(error);
       }
-      _legacyFindAndModify.call(_this, castedQuery, castedDoc, opts, callback);
+      _legacyFindAndModify.call(_this, castedQuery, castedDoc, opts, cb);
     };
 
     try {
@@ -3428,7 +3440,7 @@ Query.prototype._findAndModify = function(type, callback) {
       callback(error);
     }
   } else {
-    _legacyFindAndModify.call(_this, castedQuery, castedDoc, opts, callback);
+    _legacyFindAndModify.call(_this, castedQuery, castedDoc, opts, cb);
   }
 
   return this;

package/lib/schema/documentarray.js

@@ -362,7 +362,9 @@ DocumentArray.prototype.cast = function(value, doc, init, prev, options) {
 
     if (value[i] instanceof Subdocument) {
       // Might not have the correct index yet, so ensure it does.
-      value[i].$setIndex(i);
+      if (value[i].__index == null) {
+        value[i].$setIndex(i);
+      }
     } else if (value[i] != null) {
       if (init) {
         if (doc) {

package/lib/types/array.js

@@ -14,6 +14,7 @@ const utils = require('../utils');
 const util = require('util');
 
 const arrayParentSymbol = require('../helpers/symbols').arrayParentSymbol;
+const arraySchemaSymbol = require('../helpers/symbols').arraySchemaSymbol;
 const isMongooseObject = utils.isMongooseObject;
 
 /**
@@ -44,7 +45,7 @@ function MongooseArray(values, path, doc) {
   arr.isMongooseArray = true;
   arr.validators = [];
   arr._atomics = {};
-  arr._schema = void 0;
+  arr[arraySchemaSymbol] = void 0;
   if (util.inspect.custom) {
     arr[util.inspect.custom] = arr.inspect;
   }
@@ -55,7 +56,7 @@ function MongooseArray(values, path, doc) {
   // to make more proof against unusual node environments
   if (doc && doc instanceof Document) {
     arr[arrayParentSymbol] = doc;
-    arr._schema = doc.schema.path(path);
+    arr[arraySchemaSymbol] = doc.schema.path(path);
   }
 
   return arr;
@@ -86,6 +87,14 @@ MongooseArray.mixin = {
     return this[arrayParentSymbol];
   },
 
+  /*!
+   * ignore
+   */
+
+  $schema: function() {
+    return this[arraySchemaSymbol];
+  },
+
   /**
    * Casts a member based on this arrays schema.
    *
@@ -122,10 +131,10 @@ MongooseArray.mixin = {
       if (!isDisc) {
         value = new Model(value);
       }
-      return this._schema.caster.applySetters(value, this[arrayParentSymbol], true);
+      return this[arraySchemaSymbol].caster.applySetters(value, this[arrayParentSymbol], true);
     }
 
-    return this._schema.caster.applySetters(value, this[arrayParentSymbol], false);
+    return this[arraySchemaSymbol].caster.applySetters(value, this[arrayParentSymbol], false);
   },
 
   /**
@@ -321,7 +330,7 @@ MongooseArray.mixin = {
   push: function() {
     _checkManualPopulation(this, arguments);
     let values = [].map.call(arguments, this._mapCast, this);
-    values = this._schema.applySetters(values, this[arrayParentSymbol], undefined,
+    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol], undefined,
       undefined, { skipDocumentArrayCast: true });
     const ret = [].push.apply(this, values);
 
@@ -612,7 +621,7 @@ MongooseArray.mixin = {
     _checkManualPopulation(this, arguments);
 
     let values = [].map.call(arguments, this._cast, this);
-    values = this._schema.applySetters(values, this[arrayParentSymbol]);
+    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
     [].unshift.apply(this, values);
     this._registerAtomic('$set', this);
     this._markModified();
@@ -658,7 +667,7 @@ MongooseArray.mixin = {
     _checkManualPopulation(this, arguments);
 
     let values = [].map.call(arguments, this._mapCast, this);
-    values = this._schema.applySetters(values, this[arrayParentSymbol]);
+    values = this[arraySchemaSymbol].applySetters(values, this[arrayParentSymbol]);
     const added = [];
     let type = '';
     if (values[0] instanceof EmbeddedDocument) {
@@ -786,6 +795,20 @@ MongooseArray.mixin = {
       }
     }
     return -1;
+  },
+
+  /**
+   * Return whether or not the `obj` is included in the array.
+   *
+   * @param {Object} obj the item to check
+   * @return {Boolean}
+   * @api public
+   * @method includes
+   * @memberOf MongooseArray
+   */
+
+  includes: function includes(obj) {
+    return this.indexOf(obj) !== -1;
   }
 };
 
@@ -830,7 +853,9 @@ function _isAllSubdocs(docs, ref) {
  */
 
 function _checkManualPopulation(arr, docs) {
-  const ref = get(arr, '_schema.caster.options.ref', null);
+  const ref = arr == null ?
+    null :
+    get(arr[arraySchemaSymbol], 'caster.options.ref', null);
   if (arr.length === 0 &&
       docs.length > 0) {
     if (_isAllSubdocs(docs, ref)) {

package/lib/types/documentarray.js

@@ -8,13 +8,13 @@ const Document = require('../document');
 const MongooseArray = require('./array');
 const ObjectId = require('./objectid');
 const castObjectId = require('../cast/objectid');
-const get = require('../helpers/get');
 const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 const internalToObjectOptions = require('../options').internalToObjectOptions;
 const util = require('util');
 const utils = require('../utils');
 
 const arrayParentSymbol = require('../helpers/symbols').arrayParentSymbol;
+const arraySchemaSymbol = require('../helpers/symbols').arraySchemaSymbol;
 const documentArrayParent = require('../helpers/symbols').documentArrayParent;
 
 /*!
@@ -50,7 +50,7 @@ function MongooseDocumentArray(values, path, doc) {
     isMongooseDocumentArray: true,
     validators: [],
     _atomics: {},
-    _schema: void 0,
+    [arraySchemaSymbol]: void 0,
     _handlers: void 0
   };
 
@@ -95,21 +95,23 @@ function MongooseDocumentArray(values, path, doc) {
   // to make more proof against unusual node environments
   if (doc && doc instanceof Document) {
     arr[arrayParentSymbol] = doc;
-    arr._schema = doc.schema.path(path);
+    arr[arraySchemaSymbol] = doc.schema.path(path);
 
     // `schema.path()` doesn't drill into nested arrays properly yet, see
     // gh-6398, gh-6602. This is a workaround because nested arrays are
     // always plain non-document arrays, so once you get to a document array
     // nesting is done. Matryoshka code.
-    while (get(arr, '_schema.$isMongooseArray') &&
-        !get(arr, '_schema.$isMongooseDocumentArray')) {
-      arr._schema = arr._schema.casterConstructor;
+    while (arr != null &&
+        arr[arraySchemaSymbol] != null &&
+        arr[arraySchemaSymbol].$isMongooseArray &&
+        !arr[arraySchemaSymbol].$isMongooseDocumentArray) {
+      arr[arraySchemaSymbol] = arr[arraySchemaSymbol].casterConstructor;
     }
 
     // Tricky but this may be a document array embedded in a normal array,
     // in which case `path` would point to the embedded array. See #6405, #6398
-    if (arr._schema && !arr._schema.$isMongooseDocumentArray) {
-      arr._schema = arr._schema.casterConstructor;
+    if (arr[arraySchemaSymbol] && !arr[arraySchemaSymbol].$isMongooseDocumentArray) {
+      arr[arraySchemaSymbol] = arr[arraySchemaSymbol].casterConstructor;
     }
 
     arr._handlers = {
@@ -145,7 +147,7 @@ MongooseDocumentArray.mixin = {
    */
 
   _cast: function(value, index) {
-    let Constructor = this._schema.casterConstructor;
+    let Constructor = this[arraySchemaSymbol].casterConstructor;
     const isInstance = Constructor.$isMongooseDocumentArray ?
       value && value.isMongooseDocumentArray :
       value instanceof Constructor;
@@ -294,7 +296,7 @@ MongooseDocumentArray.mixin = {
    */
 
   create: function(obj) {
-    let Constructor = this._schema.casterConstructor;
+    let Constructor = this[arraySchemaSymbol].casterConstructor;
     if (obj &&
         Constructor.discriminators &&
         Constructor.schema &&

package/lib/types/map.js

@@ -83,6 +83,11 @@ class MongooseMap extends Map {
     }
   }
 
+  delete(key) {
+    this.set(key, undefined);
+    super.delete(key);
+  }
+
   toBSON() {
     return new Map(this);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.5.3",
+  "version": "5.5.4",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -25,7 +25,7 @@
     "mongodb": "3.2.2",
     "mongodb-core": "3.2.2",
     "mongoose-legacy-pluralize": "1.0.2",
-    "mpath": "0.5.1",
+    "mpath": "0.5.2",
     "mquery": "3.2.0",
     "ms": "2.1.1",
     "regexp-clone": "0.0.1",