mongoose 5.5.0 → 5.5.4

package/History.md

@@ -1,3 +1,45 @@
+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
+ * fix(document): handle pushing a doc onto a discriminator that contains a doc array #7704
+ * fix(update): run setters on array elements when doing $set #7679
+ * fix: correct usage of arguments while buffering commands #7718 [rzymek](https://github.com/rzymek)
+ * fix(document): avoid error clearing modified subpaths if doc not defined #7715 [bitflower](https://github.com/bitflower)
+ * refactor(array): move `_parent` property behind a symbol #7726 #7700
+ * docs(model): list out all operations and options for `bulkWrite()` #7055
+ * docs(aggregate): use `eachAsync()` instead of nonexistent `each()` #7699
+ * docs(validation): add CastError validation example #7514
+ * docs(query+model): list out all options and callback details for Model.updateX() and Query#updateX() #7646
+
+5.5.2 / 2019-04-16
+==================
+ * fix(document): support setting nested path to non-POJO object #7639
+ * perf(connection): remove leaked event handler in `Model.init()` so `deleteModel()` frees all memory #7682
+ * fix(timestamps): handle custom statics that conflict with built-in functions (like mongoose-delete plugin) #7698
+ * fix(populate): make `Document#populated()` work for populated subdocs #7685
+ * fix(document): support `.set()` on document array underneath embedded discriminator path #7656
+
+5.5.1 / 2019-04-11
+==================
+ * fix(document): correctly overwrite all properties when setting a single nested subdoc #7660 #7681
+ * fix(array): allow customization of array required validator #7696 [freewil](https://github.com/freewil)
+ * fix(discriminator): handle embedded discriminators when casting array defaults #7687
+ * fix(collection): ensure collection functions return a promise even if disconnected #7676
+ * fix(schematype): avoid indexing properties with `{ unique: false, index: false }` #7620
+ * fix(aggregate): make `Aggregate#model()` with no arguments return the aggregation's model #7608
+
 5.5.0 / 2019-04-08
 ==================
  * feat(model): support applying hooks to custom static functions #5982
@@ -9,7 +51,7 @@
  * feat(model): print warning when calling create() incorrectly with a session #7535
  * feat(document): add Document#isEmpty() and corresponding helpers for nested paths #5369
  * feat(document): add `getters` option to Document#get() #7233
- feat(query): add Query#projection() to get or overwrite the current projection #7384
+ * feat(query): add Query#projection() to get or overwrite the current projection #7384
  * fix(document): set full validator path on validatorProperties if `propsParameter` set on validator #7447
  * feat(document): add Document#directModifiedPaths() #7373
  * feat(document): add $locals property #7691

package/lib/aggregate.js

@@ -80,14 +80,26 @@ function Aggregate(pipeline) {
 Aggregate.prototype.options;
 
 /**
- * Binds this aggregate to a model.
+ * Get/set the model that this aggregation will execute on.
  *
- * @param {Model} model the model to which the aggregate is to be bound
- * @return {Aggregate}
+ * ####Example:
+ *     const aggregate = MyModel.aggregate([{ $match: { answer: 42 } }]);
+ *     aggregate.model() === MyModel; // true
+ *
+ *     // Change the model. There's rarely any reason to do this.
+ *     aggregate.model(SomeOtherModel);
+ *     aggregate.model() === SomeOtherModel; // true
+ *
+ * @param {Model} [model] the model to which the aggregate is to be bound
+ * @return {Aggregate|Model} if model is passed, will return `this`, otherwise will return the model
  * @api public
  */
 
 Aggregate.prototype.model = function(model) {
+  if (arguments.length === 0) {
+    return this._model;
+  }
+
   this._model = model;
   if (model.schema != null) {
     if (this.options.readPreference == null &&
@@ -790,7 +802,7 @@ Aggregate.prototype.option = function(value) {
  * ####Example:
  *
  *     var cursor = Model.aggregate(..).cursor({ batchSize: 1000 }).exec();
- *     cursor.each(function(error, doc) {
+ *     cursor.eachAsync(function(error, doc) {
  *       // use doc
  *     });
  *

package/lib/connection.js

@@ -361,7 +361,13 @@ Connection.prototype.dropCollection = _wrapConnHelper(function dropCollection(co
  */
 
 Connection.prototype.dropDatabase = _wrapConnHelper(function dropDatabase(cb) {
-  this.$internalEmitter.emit('dropDatabase');
+  // If `dropDatabase()` is called, this model's collection will not be
+  // init-ed. It is sufficiently common to call `dropDatabase()` after
+  // `mongoose.connect()` but before creating models that we want to
+  // support this. See gh-6967
+  for (const name of Object.keys(this.models)) {
+    delete this.models[name].$init;
+  }
   this.db.dropDatabase(cb);
 });
 

package/lib/document.js

@@ -100,13 +100,15 @@ function Document(obj, fields, skipId, options) {
     $__hasIncludedChildren(fields) :
     {};
 
-  this.$__buildDoc(obj, fields, skipId, exclude, hasIncludedChildren, false);
+  if (this._doc == null) {
+    this.$__buildDoc(obj, fields, skipId, exclude, hasIncludedChildren, false);
 
-  // By default, defaults get applied **before** setting initial values
-  // Re: gh-6155
-  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, true, {
-    isNew: this.isNew
-  });
+    // By default, defaults get applied **before** setting initial values
+    // Re: gh-6155
+    $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, true, {
+      isNew: this.isNew
+    });
+  }
 
   if (obj) {
     if (obj instanceof Document) {
@@ -788,6 +790,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
       return this;
     }
+  } else {
+    this.$__.$setCalled.add(path);
   }
 
   function _handleIndex(i) {
@@ -806,7 +810,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
       delete this._doc[key];
     }
 
-    if (utils.isPOJO(path[key]) &&
+    if (typeof path[key] === 'object' &&
+        path[key] != null &&
         pathtype !== 'virtual' &&
         pathtype !== 'real' &&
         !(this.$__path(pathName) instanceof MixedSchema) &&
@@ -849,7 +854,10 @@ Document.prototype.$set = function $set(path, val, type, options) {
     }
   }
 
-  const pathType = this.schema.pathType(path);
+  let pathType = this.schema.pathType(path);
+  if (pathType === 'adhocOrUndefined') {
+    pathType = getEmbeddedDiscriminatorPath(this, path, { typeOnly: true });
+  }
 
   // Assume this is a Mongoose document that was copied into a POJO using
   // `Object.assign()` or `{...doc}`
@@ -858,7 +866,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   if (pathType === 'nested' && val) {
-    if (utils.isPOJO(val)) {
+    if (typeof val === 'object' && val != null) {
       if (!merge) {
         this.setValue(path, null);
         cleanModifiedSubpaths(this, path);
@@ -1056,25 +1064,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     // a single nested doc. That's to make sure we get the correct context.
     // Otherwise we would double-call the setter, see gh-7196.
     if (this.schema.singleNestedPaths[path] == null) {
-      // Init the new subdoc to the previous values of the doc, so
-      // getters/setters see the correct current state. We pass the new subdoc
-      // instead of the old subdoc because otherwise side effects in setters
-      // wouldn't work, see gh-7585
-      if (constructing && this.$__.$options.priorDoc) {
-        const priorVal = Object.assign({}, this.$__.$options.priorDoc._doc);
-        delete priorVal[this.schema.options.discriminatorKey];
-        init(this, priorVal, this._doc);
-      }
-
       val = schema.applySetters(val, this, false, priorVal);
-
-      if (constructing && this.$__.$options.priorDoc) {
-        // Clear init-ed paths afterwards, because those should be paths that
-        // were in the previous doc and should not be in the new one.
-        for (const path of Object.keys(this.$__.activePaths.states.init)) {
-          delete this._doc[path];
-        }
-      }
     }
 
     if (!didPopulate && this.$__.populated) {
@@ -1495,6 +1485,8 @@ Document.prototype.directModifiedPaths = function() {
  *     doc.$isEmpty('nested'); // false
  *     doc.nested.$isEmpty(); // false
  *
+ * @memberOf Document
+ * @instance
  * @api public
  * @method $isEmpty
  * @return {Boolean}
@@ -2555,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;
@@ -3262,7 +3254,6 @@ Document.prototype.populated = function(path, val, options) {
   }
 
   // internal
-
   if (val === true) {
     if (!this.$__.populated) {
       return undefined;
@@ -3272,6 +3263,22 @@ Document.prototype.populated = function(path, val, options) {
 
   this.$__.populated || (this.$__.populated = {});
   this.$__.populated[path] = {value: val, options: options};
+
+  // If this was a nested populate, make sure each populated doc knows
+  // about its populated children (gh-7685)
+  const pieces = path.split('.');
+  for (let i = 0; i < pieces.length - 1; ++i) {
+    const subpath = pieces.slice(0, i + 1).join('.');
+    const subdoc = this.get(subpath);
+    if (subdoc != null && subdoc.$__ != null && this.populated(subpath)) {
+      const rest = pieces.slice(i + 1).join('.');
+      subdoc.populated(rest, val, options);
+      // No need to continue because the above recursion should take care of
+      // marking the rest of the docs as populated
+      break;
+    }
+  }
+
   return val;
 };
 
@@ -3332,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/drivers/node-mongodb-native/collection.js

@@ -20,8 +20,9 @@ const util = require('util');
  * @api private
  */
 
-function NativeCollection() {
+function NativeCollection(name, options) {
   this.collection = null;
+  this.Promise = options.Promise || Promise;
   MongooseCollection.apply(this, arguments);
 }
 
@@ -115,9 +116,10 @@ const syncCollectionMethods = { watch: true };
 function iter(i) {
   NativeCollection.prototype[i] = function() {
     const collection = this.collection;
-    const args = arguments;
+    const args = Array.from(arguments);
     const _this = this;
     const debug = get(_this, 'conn.base.options.debug');
+    const lastArg = arguments[arguments.length - 1];
 
     // If user force closed, queueing will hang forever. See #5664
     if (this.opts.$wasForceClosed) {
@@ -127,8 +129,18 @@ function iter(i) {
       if (syncCollectionMethods[i]) {
         throw new Error('Collection method ' + i + ' is synchronous');
       }
-      this.addQueue(i, arguments);
-      return;
+      if (typeof lastArg === 'function') {
+        this.addQueue(i, args);
+        return;
+      }
+      return new this.Promise((resolve, reject) => {
+        this.addQueue(i, [].concat(args).concat([(err, res) => {
+          if (err != null) {
+            return reject(err);
+          }
+          resolve(res);
+        }]));
+      });
     }
 
     if (debug) {

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

@@ -8,4 +8,4 @@ exports.Binary = require('./binary');
 exports.Collection = require('./collection');
 exports.Decimal128 = require('./decimal128');
 exports.ObjectId = require('./objectid');
-exports.ReadPreference = require('./ReadPreference');
+exports.ReadPreference = require('./ReadPreference');

package/lib/helpers/document/cleanModifiedSubpaths.js

@@ -9,6 +9,9 @@ module.exports = function cleanModifiedSubpaths(doc, path, options) {
   const skipDocArrays = options.skipDocArrays;
 
   let deleted = 0;
+  if (!doc) {
+    return deleted;
+  }
   for (const modifiedPath of Object.keys(doc.$__.activePaths.states.modify)) {
     if (skipDocArrays) {
       const schemaType = doc.schema.path(modifiedPath);

package/lib/helpers/document/getEmbeddedDiscriminatorPath.js

@@ -18,8 +18,12 @@ module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
     const subpath = parts.slice(0, i + 1).join('.');
     schema = doc.schema.path(subpath);
     if (schema == null) {
+      type = 'adhocOrUndefined';
       continue;
     }
+    if (schema.instance === 'Mixed') {
+      return typeOnly ? 'real' : schema;
+    }
     type = doc.schema.pathType(subpath);
     if ((schema.$isSingleNested || schema.$isMongooseDocumentArrayElement) &&
         schema.schema.discriminators != null) {
@@ -30,11 +34,7 @@ module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
         continue;
       }
       const rest = parts.slice(i + 1).join('.');
-      schema = discriminators[discriminatorKey].path(rest);
-      if (schema != null) {
-        type = discriminators[discriminatorKey].pathType(rest);
-        break;
-      }
+      return getEmbeddedDiscriminatorPath(doc.get(subpath), rest, options);
     }
   }
 

package/lib/helpers/model/applyStaticHooks.js

@@ -7,6 +7,9 @@ module.exports = function applyStaticHooks(model, hooks, statics) {
     useErrorHandlers: true,
     numCallbackParams: 1
   };
+
+  hooks = hooks.filter(hook => hook.model !== false);
+
   model.$__insertMany = hooks.createWrapper('insertMany',
     model.$__insertMany, model, kareemOptions);
 

package/lib/helpers/query/castUpdate.js

@@ -392,8 +392,6 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
       tmp = tmp[0];
     }
     return tmp;
-  } else if (cond && op === '$set') {
-    return schema.cast(val);
   }
 
   if (op in noCastOps) {

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,13 +1,10 @@
 'use strict';
 
-exports.validatorErrorSymbol = Symbol.for('mongoose:validatorError');
-
-exports.documentArrayParent = Symbol.for('mongoose:documentArrayParent');
-
-exports.modelSymbol = Symbol.for('mongoose#Model');
-
-exports.getSymbol = Symbol.for('mongoose#Document#get');
-
-exports.objectIdSymbol = Symbol.for('mongoose#ObjectId');
-
-exports.schemaTypeSymbol = Symbol.for('mongoose#schemaType');
+exports.arrayParentSymbol = Symbol('mongoose#Array#_parent');
+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/internal.js

@@ -30,6 +30,7 @@ function InternalCache() {
   this.pathsToScopes = {};
   this.cachedRequired = {};
   this.session = null;
+  this.$setCalled = new Set();
 
   // embedded docs
   this.ownerDocument = undefined;