mongoose 6.4.7 → 6.5.0

package/lib/connection.js

@@ -491,6 +491,9 @@ Connection.prototype.transaction = function transaction(fn, options) {
             doc.set(doc.schema.options.versionKey, state.versionKey);
           }
 
+          if (state.modifiedPaths.length > 0 && doc.$__.activePaths.states.modify == null) {
+            doc.$__.activePaths.states.modify = {};
+          }
           for (const path of state.modifiedPaths) {
             doc.$__.activePaths.paths[path] = 'modify';
             doc.$__.activePaths.states.modify[path] = true;
@@ -550,8 +553,8 @@ Connection.prototype.dropDatabase = _wrapConnHelper(function dropDatabase(cb) {
   // init-ed. It is sufficiently common to call `dropDatabase()` after
   // `mongoose.connect()` but before creating models that we want to
   // support this. See gh-6796
-  for (const name of Object.keys(this.models)) {
-    delete this.models[name].$init;
+  for (const model of Object.values(this.models)) {
+    delete model.$init;
   }
   this.db.dropDatabase(cb);
 });
@@ -840,6 +843,11 @@ Connection.prototype.openUri = function(uri, options, callback) {
     );
   }
 
+  for (const model of Object.values(this.models)) {
+    // Errors handled internally, so safe to ignore error
+    model.init(function $modelInitNoop() {});
+  }
+
   return this.$initialConnection;
 };
 
@@ -961,6 +969,13 @@ Connection.prototype.close = function(force, callback) {
     this.$wasForceClosed = !!force;
   }
 
+  for (const model of Object.values(this.models)) {
+    // If manually disconnecting, make sure to clear each model's `$init`
+    // promise, so Mongoose knows to re-run `init()` in case the
+    // connection is re-opened. See gh-12047.
+    delete model.$init;
+  }
+
   return promiseOrCallback(callback, cb => {
     this._close(force, false, cb);
   });
@@ -1462,6 +1477,11 @@ Connection.prototype.setClient = function setClient(client) {
   this._connectionString = client.s.url;
   _setClient(this, client, {}, client.s.options.dbName);
 
+  for (const model of Object.values(this.models)) {
+    // Errors handled internally, so safe to ignore error
+    model.init(function $modelInitNoop() {});
+  }
+
   return this;
 };
 

package/lib/cursor/ChangeStream.js

@@ -20,6 +20,13 @@ class ChangeStream extends EventEmitter {
     this.pipeline = pipeline;
     this.options = options;
 
+    if (options && options.hydrate && !options.model) {
+      throw new Error(
+        'Cannot create change stream with `hydrate: true` ' +
+        'unless calling `Model.watch()`'
+      );
+    }
+
     // This wrapper is necessary because of buffering.
     changeStreamThunk((err, driverChangeStream) => {
       if (err != null) {
@@ -46,7 +53,12 @@ class ChangeStream extends EventEmitter {
         });
 
         ['close', 'change', 'end', 'error'].forEach(ev => {
-          this.driverChangeStream.on(ev, data => this.emit(ev, data));
+          this.driverChangeStream.on(ev, data => {
+            if (data.fullDocument != null && this.options && this.options.hydrate) {
+              data.fullDocument = this.options.model.hydrate(data.fullDocument);
+            }
+            this.emit(ev, data);
+          });
         });
       });
 
@@ -69,6 +81,32 @@ class ChangeStream extends EventEmitter {
   }
 
   next(cb) {
+    if (this.options && this.options.hydrate) {
+      if (cb != null) {
+        const originalCb = cb;
+        cb = (err, data) => {
+          if (err != null) {
+            return originalCb(err);
+          }
+          if (data.fullDocument != null) {
+            data.fullDocument = this.options.model.hydrate(data.fullDocument);
+          }
+          return originalCb(null, data);
+        };
+      }
+
+      let maybePromise = this.driverChangeStream.next(cb);
+      if (maybePromise && typeof maybePromise.then === 'function') {
+        maybePromise = maybePromise.then(data => {
+          if (data.fullDocument != null) {
+            data.fullDocument = this.options.model.hydrate(data.fullDocument);
+          }
+          return data;
+        });
+      }
+      return maybePromise;
+    }
+
     return this.driverChangeStream.next(cb);
   }
 

package/lib/document.js

@@ -18,6 +18,8 @@ const ValidatorError = require('./error/validator');
 const VirtualType = require('./virtualtype');
 const $__hasIncludedChildren = require('./helpers/projection/hasIncludedChildren');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
+const castNumber = require('./cast/number');
+const applyDefaults = require('./helpers/document/applyDefaults');
 const cleanModifiedSubpaths = require('./helpers/document/cleanModifiedSubpaths');
 const compile = require('./helpers/document/compile').compile;
 const defineKey = require('./helpers/document/compile').defineKey;
@@ -93,7 +95,11 @@ function Document(obj, fields, skipId, options) {
   }
 
   this.$__ = new InternalCache();
-  this.$isNew = 'isNew' in options ? options.isNew : true;
+
+  // Avoid setting `isNew` to `true`, because it is `true` by default
+  if (options.isNew != null && options.isNew !== true) {
+    this.$isNew = options.isNew;
+  }
 
   if (options.priorDoc != null) {
     this.$__.priorDoc = options.priorDoc;
@@ -116,13 +122,12 @@ function Document(obj, fields, skipId, options) {
   const schema = this.$__schema;
 
   if (typeof fields === 'boolean' || fields === 'throw') {
-    this.$__.strictMode = fields;
+    if (fields !== true) {
+      this.$__.strictMode = fields;
+    }
     fields = undefined;
-  } else {
+  } else if (schema.options.strict !== true) {
     this.$__.strictMode = schema.options.strict;
-    if (fields != null) {
-      this.$__.selected = fields;
-    }
   }
 
   const requiredPaths = schema.requiredPaths(true);
@@ -134,9 +139,9 @@ function Document(obj, fields, skipId, options) {
 
   // determine if this doc is a result of a query with
   // excluded fields
-  if (utils.isPOJO(fields)) {
+  if (utils.isPOJO(fields) && Object.keys(fields).length > 0) {
     exclude = isExclusive(fields);
-    this.$__.fields = fields;
+    this.$__.selected = fields;
     this.$__.exclude = exclude;
   }
 
@@ -150,7 +155,7 @@ function Document(obj, fields, skipId, options) {
     // By default, defaults get applied **before** setting initial values
     // Re: gh-6155
     if (defaults) {
-      $__applyDefaults(this, fields, exclude, hasIncludedChildren, true, null);
+      applyDefaults(this, fields, exclude, hasIncludedChildren, true, null);
     }
   }
   if (obj) {
@@ -174,7 +179,7 @@ function Document(obj, fields, skipId, options) {
       this.$__.skipDefaults = options.skipDefaults;
     }
   } else if (defaults) {
-    $__applyDefaults(this, fields, exclude, hasIncludedChildren, false, options.skipDefaults);
+    applyDefaults(this, fields, exclude, hasIncludedChildren, false, options.skipDefaults);
   }
 
   if (!this.$__.strictMode && obj) {
@@ -260,6 +265,12 @@ Object.defineProperty(Document.prototype, 'errors', {
   }
 });
 
+/*!
+ * ignore
+ */
+
+Document.prototype.$isNew = true;
+
 /*!
  * Document exposes the NodeJS event emitter API, so you can use
  * `on`, `once`, etc.
@@ -441,122 +452,6 @@ Object.defineProperty(Document.prototype, '$op', {
   }
 });
 
-/*!
- * ignore
- */
-
-function $__applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSetters, pathsToSkip) {
-  const paths = Object.keys(doc.$__schema.paths);
-  const plen = paths.length;
-
-  for (let i = 0; i < plen; ++i) {
-    let def;
-    let curPath = '';
-    const p = paths[i];
-
-    if (p === '_id' && doc.$__.skipId) {
-      continue;
-    }
-
-    const type = doc.$__schema.paths[p];
-    const path = type.splitPath();
-    const len = path.length;
-    let included = false;
-    let doc_ = doc._doc;
-    for (let j = 0; j < len; ++j) {
-      if (doc_ == null) {
-        break;
-      }
-
-      const piece = path[j];
-      curPath += (!curPath.length ? '' : '.') + piece;
-
-      if (exclude === true) {
-        if (curPath in fields) {
-          break;
-        }
-      } else if (exclude === false && fields && !included) {
-        const hasSubpaths = type.$isSingleNested || type.$isMongooseDocumentArray;
-        if (curPath in fields || (hasSubpaths && hasIncludedChildren != null && hasIncludedChildren[curPath])) {
-          included = true;
-        } else if (hasIncludedChildren != null && !hasIncludedChildren[curPath]) {
-          break;
-        }
-      }
-
-      if (j === len - 1) {
-        if (doc_[piece] !== void 0) {
-          break;
-        }
-
-        if (typeof type.defaultValue === 'function') {
-          if (!type.defaultValue.$runBeforeSetters && isBeforeSetters) {
-            break;
-          }
-          if (type.defaultValue.$runBeforeSetters && !isBeforeSetters) {
-            break;
-          }
-        } else if (!isBeforeSetters) {
-          // Non-function defaults should always run **before** setters
-          continue;
-        }
-
-        if (pathsToSkip && pathsToSkip[curPath]) {
-          break;
-        }
-
-        if (fields && exclude !== null) {
-          if (exclude === true) {
-            // apply defaults to all non-excluded fields
-            if (p in fields) {
-              continue;
-            }
-
-            try {
-              def = type.getDefault(doc, false);
-            } catch (err) {
-              doc.invalidate(p, err);
-              break;
-            }
-
-            if (typeof def !== 'undefined') {
-              doc_[piece] = def;
-              doc.$__.activePaths.default(p);
-            }
-          } else if (included) {
-            // selected field
-            try {
-              def = type.getDefault(doc, false);
-            } catch (err) {
-              doc.invalidate(p, err);
-              break;
-            }
-
-            if (typeof def !== 'undefined') {
-              doc_[piece] = def;
-              doc.$__.activePaths.default(p);
-            }
-          }
-        } else {
-          try {
-            def = type.getDefault(doc, false);
-          } catch (err) {
-            doc.invalidate(p, err);
-            break;
-          }
-
-          if (typeof def !== 'undefined') {
-            doc_[piece] = def;
-            doc.$__.activePaths.default(p);
-          }
-        }
-      } else {
-        doc_ = doc_[piece];
-      }
-    }
-  }
-}
-
 /*!
  * ignore
  */
@@ -792,10 +687,11 @@ Document.prototype.$__init = function(doc, opts) {
   this.$emit('init', this);
   this.constructor.emit('init', this);
 
-  const hasIncludedChildren = this.$__.exclude === false && this.$__.fields ?
-    $__hasIncludedChildren(this.$__.fields) :
+  const hasIncludedChildren = this.$__.exclude === false && this.$__.selected ?
+    $__hasIncludedChildren(this.$__.selected) :
     null;
-  $__applyDefaults(this, this.$__.fields, this.$__.exclude, hasIncludedChildren, false, this.$__.skipDefaults);
+
+  applyDefaults(this, this.$__.selected, this.$__.exclude, hasIncludedChildren, false, this.$__.skipDefaults);
 
   return this;
 };
@@ -863,7 +759,13 @@ function init(self, obj, doc, opts, prefix) {
 
         if (schemaType && !wasPopulated) {
           try {
-            doc[i] = schemaType.cast(obj[i], self, true);
+            if (opts && opts.setters) {
+              // Call applySetters with `init = false` because otherwise setters are a noop
+              const overrideInit = false;
+              doc[i] = schemaType.applySetters(obj[i], self, overrideInit);
+            } else {
+              doc[i] = schemaType.cast(obj[i], self, true);
+            }
           } catch (e) {
             self.invalidate(e.path, new ValidatorError({
               path: e.path,
@@ -1649,7 +1551,7 @@ Document.prototype.$__shouldModify = function(pathToMark, path, options, constru
     return true;
   }
 
-  if (val === void 0 && path in this.$__.activePaths.states.default) {
+  if (val === void 0 && path in this.$__.activePaths.getStatePaths('default')) {
     // we're just unsetting the default value which was never saved
     return false;
   }
@@ -1669,7 +1571,7 @@ Document.prototype.$__shouldModify = function(pathToMark, path, options, constru
   if (!constructing &&
       val !== null &&
       val !== undefined &&
-      path in this.$__.activePaths.states.default &&
+      path in this.$__.activePaths.getStatePaths('default') &&
       deepEqual(val, schema.getDefault(this, constructing))) {
     // a path with a default was $unset on the server
     // and the user is setting it to the same value again
@@ -1702,6 +1604,12 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
     schema, val, priorVal);
 
   if (shouldModify) {
+    if (this.$__.primitiveAtomics && this.$__.primitiveAtomics[path]) {
+      delete this.$__.primitiveAtomics[path];
+      if (Object.keys(this.$__.primitiveAtomics).length === 0) {
+        delete this.$__.primitiveAtomics;
+      }
+    }
     this.markModified(pathToMark);
 
     // handle directly setting arrays (gh-1126)
@@ -1772,6 +1680,68 @@ Document.prototype.$__getValue = function(path) {
   return utils.getValue(path, this._doc);
 };
 
+/**
+ * Increments the numeric value at `path` by the given `val`.
+ * When you call `save()` on this document, Mongoose will send a
+ * [`$inc`](https://www.mongodb.com/docs/manual/reference/operator/update/inc/)
+ * as opposed to a `$set`.
+ *
+ * #### Example:
+ *     const schema = new Schema({ counter: Number });
+ *     const Test = db.model('Test', schema);
+ *
+ *     const doc = await Test.create({ counter: 0 });
+ *     doc.$inc('counter', 2);
+ *     await doc.save(); // Sends a `{ $inc: { counter: 2 } }` to MongoDB
+ *     doc.counter; // 2
+ *
+ *     doc.counter += 2;
+ *     await doc.save(); // Sends a `{ $set: { counter: 2 } }` to MongoDB
+ *
+ * @param {String|Array} path path or paths to update
+ * @param {Number} val increment `path` by this value
+ * @return {Document} this
+ */
+
+Document.prototype.$inc = function $inc(path, val) {
+  if (val == null) {
+    val = 1;
+  }
+
+  if (Array.isArray(path)) {
+    path.forEach((p) => this.$inc(p, val));
+    return this;
+  }
+
+  const schemaType = this.$__path(path);
+  if (schemaType == null) {
+    if (this.$__.strictMode === 'throw') {
+      throw new StrictModeError(path);
+    } else if (this.$__.strictMode === true) {
+      return this;
+    }
+  } else if (schemaType.instance !== 'Number') {
+    this.invalidate(path, new MongooseError.CastError(schemaType.instance, val, path));
+    return this;
+  }
+
+  try {
+    val = castNumber(val);
+  } catch (err) {
+    this.invalidate(path, new MongooseError.CastError('number', val, path, err));
+  }
+
+  const currentValue = this.$__getValue(path);
+
+  this.$__setValue(path, currentValue + val);
+
+  this.$__.primitiveAtomics = this.$__.primitiveAtomics || {};
+  this.$__.primitiveAtomics[path] = { $inc: val };
+  this.markModified(path);
+
+  return this;
+};
+
 /**
  * Sets a raw value for a path (no casting, setters, transformations)
  *
@@ -1981,7 +1951,7 @@ Document.prototype.$ignore = function(path) {
  */
 
 Document.prototype.directModifiedPaths = function() {
-  return Object.keys(this.$__.activePaths.states.modify);
+  return Object.keys(this.$__.activePaths.getStatePaths('modify'));
 };
 
 /**
@@ -2065,7 +2035,7 @@ function _isEmpty(v) {
 Document.prototype.modifiedPaths = function(options) {
   options = options || {};
 
-  const directModifiedPaths = Object.keys(this.$__.activePaths.states.modify);
+  const directModifiedPaths = Object.keys(this.$__.activePaths.getStatePaths('modify'));
   const result = new Set();
 
   let i = 0;
@@ -2144,7 +2114,7 @@ Document.prototype[documentModifiedPaths] = Document.prototype.modifiedPaths;
 
 Document.prototype.isModified = function(paths, modifiedPaths) {
   if (paths) {
-    const directModifiedPaths = Object.keys(this.$__.activePaths.states.modify);
+    const directModifiedPaths = Object.keys(this.$__.activePaths.getStatePaths('modify'));
     if (directModifiedPaths.length === 0) {
       return false;
     }
@@ -2202,7 +2172,7 @@ Document.prototype.$isDefault = function(path) {
   }
 
   if (typeof path === 'string' && path.indexOf(' ') === -1) {
-    return this.$__.activePaths.states.default.hasOwnProperty(path);
+    return this.$__.activePaths.getStatePaths('default').hasOwnProperty(path);
   }
 
   let paths = path;
@@ -2210,7 +2180,7 @@ Document.prototype.$isDefault = function(path) {
     paths = paths.split(' ');
   }
 
-  return paths.some(path => this.$__.activePaths.states.default.hasOwnProperty(path));
+  return paths.some(path => this.$__.activePaths.getStatePaths('default').hasOwnProperty(path));
 };
 
 /**
@@ -2264,7 +2234,7 @@ Document.prototype.isDirectModified = function(path) {
   }
 
   if (typeof path === 'string' && path.indexOf(' ') === -1) {
-    return this.$__.activePaths.states.modify.hasOwnProperty(path);
+    return this.$__.activePaths.getStatePaths('modify').hasOwnProperty(path);
   }
 
   let paths = path;
@@ -2272,7 +2242,7 @@ Document.prototype.isDirectModified = function(path) {
     paths = paths.split(' ');
   }
 
-  return paths.some(path => this.$__.activePaths.states.modify.hasOwnProperty(path));
+  return paths.some(path => this.$__.activePaths.getStatePaths('modify').hasOwnProperty(path));
 };
 
 /**
@@ -2289,7 +2259,7 @@ Document.prototype.isInit = function(path) {
   }
 
   if (typeof path === 'string' && path.indexOf(' ') === -1) {
-    return this.$__.activePaths.states.init.hasOwnProperty(path);
+    return this.$__.activePaths.getStatePaths('init').hasOwnProperty(path);
   }
 
   let paths = path;
@@ -2297,7 +2267,7 @@ Document.prototype.isInit = function(path) {
     paths = paths.split(' ');
   }
 
-  return paths.some(path => this.$__.activePaths.states.init.hasOwnProperty(path));
+  return paths.some(path => this.$__.activePaths.getStatePaths('init').hasOwnProperty(path));
 };
 
 /**
@@ -2533,7 +2503,7 @@ Document.prototype.$validate = Document.prototype.validate;
  */
 
 function _evaluateRequiredFunctions(doc) {
-  const requiredFields = Object.keys(doc.$__.activePaths.states.require);
+  const requiredFields = Object.keys(doc.$__.activePaths.getStatePaths('require'));
   let i = 0;
   const len = requiredFields.length;
   for (i = 0; i < len; ++i) {
@@ -2561,7 +2531,7 @@ function _getPathsToValidate(doc) {
 
   _evaluateRequiredFunctions(doc);
   // only validate required fields when necessary
-  let paths = new Set(Object.keys(doc.$__.activePaths.states.require).filter(function(path) {
+  let paths = new Set(Object.keys(doc.$__.activePaths.getStatePaths('require')).filter(function(path) {
     if (!doc.$__isSelected(path) && !doc.$isModified(path)) {
       return false;
     }
@@ -2571,9 +2541,9 @@ function _getPathsToValidate(doc) {
     return true;
   }));
 
-  Object.keys(doc.$__.activePaths.states.init).forEach(addToPaths);
-  Object.keys(doc.$__.activePaths.states.modify).forEach(addToPaths);
-  Object.keys(doc.$__.activePaths.states.default).forEach(addToPaths);
+  Object.keys(doc.$__.activePaths.getStatePaths('init')).forEach(addToPaths);
+  Object.keys(doc.$__.activePaths.getStatePaths('modify')).forEach(addToPaths);
+  Object.keys(doc.$__.activePaths.getStatePaths('default')).forEach(addToPaths);
   function addToPaths(p) { paths.add(p); }
 
   const subdocs = doc.$getAllSubdocs();
@@ -3296,8 +3266,8 @@ Document.prototype.$__reset = function reset() {
 
   this.$__.backup = {};
   this.$__.backup.activePaths = {
-    modify: Object.assign({}, this.$__.activePaths.states.modify),
-    default: Object.assign({}, this.$__.activePaths.states.default)
+    modify: Object.assign({}, this.$__.activePaths.getStatePaths('modify')),
+    default: Object.assign({}, this.$__.activePaths.getStatePaths('default'))
   };
   this.$__.backup.validationError = this.$__.validationError;
   this.$__.backup.errors = this.$errors;

package/lib/error/validation.js

@@ -52,6 +52,15 @@ class ValidationError extends MongooseError {
   * add message
   */
   addError(path, error) {
+    if (error instanceof ValidationError) {
+      const { errors } = error;
+      for (const errorPath of Object.keys(errors)) {
+        this.addError(`${path}.${errorPath}`, errors[errorPath]);
+      }
+
+      return;
+    }
+
     this.errors[path] = error;
     this.message = this._message + ': ' + _generateMessage(this);
   }

package/lib/helpers/document/applyDefaults.js

@@ -0,0 +1,115 @@
+'use strict';
+
+module.exports = function applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSetters, pathsToSkip) {
+  const paths = Object.keys(doc.$__schema.paths);
+  const plen = paths.length;
+
+  for (let i = 0; i < plen; ++i) {
+    let def;
+    let curPath = '';
+    const p = paths[i];
+
+    if (p === '_id' && doc.$__.skipId) {
+      continue;
+    }
+
+    const type = doc.$__schema.paths[p];
+    const path = type.splitPath();
+    const len = path.length;
+    let included = false;
+    let doc_ = doc._doc;
+    for (let j = 0; j < len; ++j) {
+      if (doc_ == null) {
+        break;
+      }
+
+      const piece = path[j];
+      curPath += (!curPath.length ? '' : '.') + piece;
+
+      if (exclude === true) {
+        if (curPath in fields) {
+          break;
+        }
+      } else if (exclude === false && fields && !included) {
+        const hasSubpaths = type.$isSingleNested || type.$isMongooseDocumentArray;
+        if (curPath in fields || (hasSubpaths && hasIncludedChildren != null && hasIncludedChildren[curPath])) {
+          included = true;
+        } else if (hasIncludedChildren != null && !hasIncludedChildren[curPath]) {
+          break;
+        }
+      }
+
+      if (j === len - 1) {
+        if (doc_[piece] !== void 0) {
+          break;
+        }
+
+        if (isBeforeSetters != null) {
+          if (typeof type.defaultValue === 'function') {
+            if (!type.defaultValue.$runBeforeSetters && isBeforeSetters) {
+              break;
+            }
+            if (type.defaultValue.$runBeforeSetters && !isBeforeSetters) {
+              break;
+            }
+          } else if (!isBeforeSetters) {
+            // Non-function defaults should always run **before** setters
+            continue;
+          }
+        }
+
+        if (pathsToSkip && pathsToSkip[curPath]) {
+          break;
+        }
+
+        if (fields && exclude !== null) {
+          if (exclude === true) {
+            // apply defaults to all non-excluded fields
+            if (p in fields) {
+              continue;
+            }
+
+            try {
+              def = type.getDefault(doc, false);
+            } catch (err) {
+              doc.invalidate(p, err);
+              break;
+            }
+
+            if (typeof def !== 'undefined') {
+              doc_[piece] = def;
+              doc.$__.activePaths.default(p);
+            }
+          } else if (included) {
+            // selected field
+            try {
+              def = type.getDefault(doc, false);
+            } catch (err) {
+              doc.invalidate(p, err);
+              break;
+            }
+
+            if (typeof def !== 'undefined') {
+              doc_[piece] = def;
+              doc.$__.activePaths.default(p);
+            }
+          }
+        } else {
+          try {
+            def = type.getDefault(doc, false);
+          } catch (err) {
+            doc.invalidate(p, err);
+            break;
+          }
+
+          if (typeof def !== 'undefined') {
+            doc_[piece] = def;
+            doc.$__.activePaths.default(p);
+          }
+        }
+      } else {
+        doc_ = doc_[piece];
+      }
+    }
+  }
+};