mongoose 6.2.10 → 6.3.1

package/lib/aggregate.js

@@ -6,7 +6,7 @@
 
 const AggregationCursor = require('./cursor/AggregationCursor');
 const Query = require('./query');
-const applyGlobalMaxTimeMS = require('./helpers/query/applyGlobalMaxTimeMS');
+const { applyGlobalMaxTimeMS, applyGlobalDiskUse } = require('./helpers/query/applyGlobalOption');
 const getConstructorName = require('./helpers/getConstructorName');
 const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
@@ -15,6 +15,8 @@ const utils = require('./utils');
 const read = Query.prototype.read;
 const readConcern = Query.prototype.readConcern;
 
+const validRedactStringValues = new Set(['$$DESCEND', '$$PRUNE', '$$KEEP']);
+
 /**
  * Aggregate constructor used for building aggregation pipelines. Do not
  * instantiate this class directly, use [Model.aggregate()](/docs/api.html#model_Model.aggregate) instead.
@@ -63,19 +65,21 @@ function Aggregate(pipeline, model) {
  * Contains options passed down to the [aggregate command](https://docs.mongodb.com/manual/reference/command/aggregate/).
  * Supported options are:
  *
- * - `readPreference`
- * - [`cursor`](./api.html#aggregate_Aggregate-cursor)
- * - [`explain`](./api.html#aggregate_Aggregate-explain)
  * - [`allowDiskUse`](./api.html#aggregate_Aggregate-allowDiskUse)
- * - `maxTimeMS`
  * - `bypassDocumentValidation`
- * - `raw`
- * - `promoteLongs`
- * - `promoteValues`
- * - `promoteBuffers`
  * - [`collation`](./api.html#aggregate_Aggregate-collation)
  * - `comment`
+ * - [`cursor`](./api.html#aggregate_Aggregate-cursor)
+ * - [`explain`](./api.html#aggregate_Aggregate-explain)
+ * - `fieldsAsRaw`
+ * - hint
+ * - let
+ * - `maxTimeMS`
+ * - `raw`
+ * - `readConcern`
+ * - `readPreference`
  * - [`session`](./api.html#aggregate_Aggregate-session)
+ * - `writeConcern`
  *
  * @property options
  * @memberOf Aggregate
@@ -374,7 +378,7 @@ Aggregate.prototype.unwind = function() {
       res.push({ $unwind: arg });
     } else if (typeof arg === 'string') {
       res.push({
-        $unwind: (arg && arg.startsWith('$')) ? arg : '$' + arg
+        $unwind: (arg[0] === '$') ? arg : '$' + arg
       });
     } else {
       throw new Error('Invalid arg "' + arg + '" to unwind(), ' +
@@ -399,7 +403,7 @@ Aggregate.prototype.unwind = function() {
  *     aggregate.replaceRoot({ x: { $concat: ['$this', '$that'] } });
  *
  * @see $replaceRoot https://docs.mongodb.org/manual/reference/operator/aggregation/replaceRoot
- * @param {String|Object} the field or document which will become the new root document
+ * @param {String|Object} newRoot the field or document which will become the new root document
  * @return {Aggregate}
  * @api public
  */
@@ -428,13 +432,13 @@ Aggregate.prototype.replaceRoot = function(newRoot) {
  *     aggregate.count("userCount");
  *
  * @see $count https://docs.mongodb.org/manual/reference/operator/aggregation/count
- * @param {String} the name of the count field
+ * @param {String} fieldName The name of the output field which has the count as its value. It must be a non-empty string, must not start with $ and must not contain the . character.
  * @return {Aggregate}
  * @api public
  */
 
-Aggregate.prototype.count = function(countName) {
-  return this.append({ $count: countName });
+Aggregate.prototype.count = function(fieldName) {
+  return this.append({ $count: fieldName });
 };
 
 /**
@@ -460,7 +464,7 @@ Aggregate.prototype.sortByCount = function(arg) {
     return this.append({ $sortByCount: arg });
   } else if (typeof arg === 'string') {
     return this.append({
-      $sortByCount: (arg && arg.startsWith('$')) ? arg : '$' + arg
+      $sortByCount: (arg[0] === '$') ? arg : '$' + arg
     });
   } else {
     throw new TypeError('Invalid arg "' + arg + '" to sortByCount(), ' +
@@ -621,9 +625,6 @@ Aggregate.prototype.unionWith = function(options) {
  */
 
 Aggregate.prototype.read = function(pref, tags) {
-  if (!this.options) {
-    this.options = {};
-  }
   read.call(this, pref, tags);
   return this;
 };
@@ -642,9 +643,6 @@ Aggregate.prototype.read = function(pref, tags) {
  */
 
 Aggregate.prototype.readConcern = function(level) {
-  if (!this.options) {
-    this.options = {};
-  }
   readConcern.call(this, level);
   return this;
 };
@@ -678,9 +676,9 @@ Aggregate.prototype.readConcern = function(level) {
 
 Aggregate.prototype.redact = function(expression, thenExpr, elseExpr) {
   if (arguments.length === 3) {
-    if ((typeof thenExpr === 'string' && !thenExpr.startsWith('$$')) ||
-        (typeof elseExpr === 'string' && !elseExpr.startsWith('$$'))) {
-      throw new Error('If thenExpr or elseExpr is string, it must start with $$. e.g. $$DESCEND, $$PRUNE, $$KEEP');
+    if ((typeof thenExpr === 'string' && !validRedactStringValues.has(thenExpr)) ||
+        (typeof elseExpr === 'string' && !validRedactStringValues.has(elseExpr))) {
+      throw new Error('If thenExpr or elseExpr is string, it must be either $$DESCEND, $$PRUNE or $$KEEP');
     }
 
     expression = {
@@ -773,7 +771,6 @@ Aggregate.prototype.explain = function(verbosity, callback) {
  *     await Model.aggregate([{ $match: { foo: 'bar' } }]).allowDiskUse(true);
  *
  * @param {Boolean} value Should tell server it can use hard drive to store data during aggregation.
- * @param {Array} [tags] optional tags for this query
  * @see mongodb https://docs.mongodb.org/manual/reference/command/aggregate/
  */
 
@@ -865,9 +862,6 @@ Aggregate.prototype.option = function(value) {
  */
 
 Aggregate.prototype.cursor = function(options) {
-  if (!this.options) {
-    this.options = {};
-  }
   this.options.cursor = options || {};
   return new AggregationCursor(this); // return this;
 };
@@ -886,9 +880,6 @@ Aggregate.prototype.cursor = function(options) {
  */
 
 Aggregate.prototype.collation = function(collation) {
-  if (!this.options) {
-    this.options = {};
-  }
   this.options.collation = collation;
   return this;
 };
@@ -982,6 +973,7 @@ Aggregate.prototype.exec = function(callback) {
   const collection = this._model.collection;
 
   applyGlobalMaxTimeMS(this.options, model);
+  applyGlobalDiskUse(this.options, model);
 
   if (this.options && this.options.cursor) {
     return new AggregationCursor(this);

package/lib/collection.js

@@ -23,13 +23,6 @@ function Collection(name, conn, opts) {
   if (opts === void 0) {
     opts = {};
   }
-  if (opts.capped === void 0) {
-    opts.capped = {};
-  }
-
-  if (typeof opts.capped === 'number') {
-    opts.capped = { size: opts.capped };
-  }
 
   this.opts = opts;
   this.name = name;

package/lib/cursor/ChangeStream.js

@@ -16,6 +16,7 @@ class ChangeStream extends EventEmitter {
 
     this.driverChangeStream = null;
     this.closed = false;
+    this.bindedEvents = false;
     this.pipeline = pipeline;
     this.options = options;
 
@@ -27,21 +28,60 @@ class ChangeStream extends EventEmitter {
       }
 
       this.driverChangeStream = driverChangeStream;
-      this._bindEvents();
       this.emit('ready');
     });
   }
 
   _bindEvents() {
+    if (this.bindedEvents) {
+      return;
+    }
+
+    this.bindedEvents = true;
+
+    if (this.driverChangeStream == null) {
+      this.once('ready', () => {
+        this.driverChangeStream.on('close', () => {
+          this.closed = true;
+        });
+
+        ['close', 'change', 'end', 'error'].forEach(ev => {
+          this.driverChangeStream.on(ev, data => this.emit(ev, data));
+        });
+      });
+
+      return;
+    }
+
     this.driverChangeStream.on('close', () => {
       this.closed = true;
     });
 
     ['close', 'change', 'end', 'error'].forEach(ev => {
-      this.driverChangeStream.on(ev, data => this.emit(ev, data));
+      this.driverChangeStream.on(ev, data => {
+        this.emit(ev, data);
+      });
     });
   }
 
+  hasNext(cb) {
+    return this.driverChangeStream.hasNext(cb);
+  }
+
+  next(cb) {
+    return this.driverChangeStream.next(cb);
+  }
+
+  on(event, handler) {
+    this._bindEvents();
+    return super.on(event, handler);
+  }
+
+  once(event, handler) {
+    this._bindEvents();
+    return super.once(event, handler);
+  }
+
   _queue(cb) {
     this.once('ready', () => cb());
   }

package/lib/cursor/QueryCursor.js

@@ -225,6 +225,8 @@ QueryCursor.prototype.next = function(callback) {
  * @param {Function} fn
  * @param {Object} [options]
  * @param {Number} [options.parallel] the number of promises to execute in parallel. Defaults to 1.
+ * @param {Number} [options.batchSize] if set, will call `fn()` with arrays of documents with length at most `batchSize`
+ * @param {Boolean} [options.continueOnError=false] if true, `eachAsync()` iterates through all docs even if `fn` throws an error. If false, `eachAsync()` throws an error immediately if the given function `fn()` throws an error.
  * @param {Function} [callback] executed when all docs have been processed
  * @return {Promise}
  * @api public

package/lib/document.js

@@ -94,7 +94,7 @@ function Document(obj, fields, skipId, options) {
   this.$__ = new InternalCache();
   this.$isNew = 'isNew' in options ? options.isNew : true;
 
-  if ('priorDoc' in options) {
+  if (options.priorDoc != null) {
     this.$__.priorDoc = options.priorDoc;
   }
 
@@ -119,7 +119,7 @@ function Document(obj, fields, skipId, options) {
     fields = undefined;
   } else {
     this.$__.strictMode = schema.options.strict;
-    if (fields !== undefined) {
+    if (fields != null) {
       this.$__.selected = fields;
     }
   }
@@ -177,8 +177,6 @@ function Document(obj, fields, skipId, options) {
     $__applyDefaults(this, fields, exclude, hasIncludedChildren, false, options.skipDefaults);
   }
 
-  this.$__._id = this._id;
-
   if (!this.$__.strictMode && obj) {
     const _this = this;
     const keys = Object.keys(this._doc);
@@ -743,8 +741,6 @@ Document.prototype.$__init = function(doc, opts) {
   this.$emit('init', this);
   this.constructor.emit('init', this);
 
-  this.$__._id = this._id;
-
   const hasIncludedChildren = this.$__.exclude === false && this.$__.fields ?
     $__hasIncludedChildren(this.$__.fields) :
     null;
@@ -1052,7 +1048,6 @@ Document.prototype.$set = function $set(path, val, type, options) {
   const merge = options.merge;
   const adhoc = type && type !== true;
   const constructing = type === true;
-  const typeKey = this.$__schema.options.typeKey;
   let adhocs;
   let keys;
   let i = 0;
@@ -1154,14 +1149,15 @@ Document.prototype.$set = function $set(path, val, type, options) {
       }
     }
 
-    // Ensure all properties are in correct order by deleting and recreating every property.
-    for (const key of Object.keys(this.$__schema.tree)) {
-      if (this._doc.hasOwnProperty(key)) {
-        const val = this._doc[key];
-        delete this._doc[key];
-        this._doc[key] = val;
-      }
+    // Ensure all properties are in correct order
+    const orderedDoc = {};
+    const orderedKeys = Object.keys(this.$__schema.tree);
+    for (let i = 0, len = orderedKeys.length; i < len; ++i) {
+      (key = orderedKeys[i]) &&
+      (this._doc.hasOwnProperty(key)) &&
+      (orderedDoc[key] = undefined);
     }
+    this._doc = Object.assign(orderedDoc, this._doc);
 
     return this;
   }
@@ -1385,6 +1381,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     }
 
     let popOpts;
+    const typeKey = this.$__schema.options.typeKey;
     if (schema.options &&
         Array.isArray(schema.options[typeKey]) &&
         schema.options[typeKey].length &&
@@ -1404,7 +1401,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       // later in `$__set()` because we don't take `_doc` when we iterate through
       // a single nested doc. That's to make sure we get the correct context.
       // Otherwise we would double-call the setter, see gh-7196.
-      val = schema.applySetters(val, this, false, priorVal);
+      val = schema.applySetters(val, this, false, priorVal, options);
     }
 
     if (Array.isArray(val) &&
@@ -2485,10 +2482,7 @@ function _getPathsToValidate(doc) {
     if (subdoc.$basePath) {
       // Remove child paths for now, because we'll be validating the whole
       // subdoc
-      if (!subdoc.$__.fullPath) {
-        subdoc.ownerDocument();
-      }
-      const fullPathToSubdoc = subdoc.$__.fullPath;
+      const fullPathToSubdoc = subdoc.$__fullPathWithIndexes();
 
       for (const p of paths) {
         if (p === null || p.startsWith(fullPathToSubdoc + '.')) {

package/lib/error/cast.js

@@ -23,7 +23,7 @@ class CastError extends MongooseError {
       const stringValue = getStringValue(value);
       const valueType = getValueType(value);
       const messageFormat = getMessageFormat(schemaType);
-      const msg = formatMessage(null, type, stringValue, path, messageFormat, valueType);
+      const msg = formatMessage(null, type, stringValue, path, messageFormat, valueType, reason);
       super(msg);
       this.init(type, value, path, reason, schemaType);
     } else {
@@ -122,7 +122,7 @@ function getMessageFormat(schemaType) {
  * ignore
  */
 
-function formatMessage(model, kind, stringValue, path, messageFormat, valueType) {
+function formatMessage(model, kind, stringValue, path, messageFormat, valueType, reason) {
   if (messageFormat != null) {
     let ret = messageFormat.
       replace('{KIND}', kind).
@@ -140,6 +140,11 @@ function formatMessage(model, kind, stringValue, path, messageFormat, valueType)
     if (model != null) {
       ret += ' for model "' + model.modelName + '"';
     }
+    if (reason != null &&
+        typeof reason.constructor === 'function' &&
+        reason.constructor.name !== 'AssertionError') {
+      ret += ' because of "' + reason.constructor.name + '"';
+    }
     return ret;
   }
 }

package/lib/error/eachAsyncMultiError.js

@@ -0,0 +1,41 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./');
+
+
+/**
+ * If `eachAsync()` is called with `continueOnError: true`, there can be
+ * multiple errors. This error class contains an `errors` property, which
+ * contains an array of all errors that occurred in `eachAsync()`.
+ *
+ * @api private
+ */
+
+class EachAsyncMultiError extends MongooseError {
+  /**
+   * @param {String} connectionString
+   */
+  constructor(errors) {
+    let preview = errors.map(e => e.message).join(', ');
+    if (preview.length > 50) {
+      preview = preview.slice(0, 50) + '...';
+    }
+    super(`eachAsync() finished with ${errors.length} errors: ${preview}`);
+
+    this.errors = errors;
+  }
+}
+
+Object.defineProperty(EachAsyncMultiError.prototype, 'name', {
+  value: 'EachAsyncMultiError'
+});
+
+/*!
+ * exports
+ */
+
+module.exports = EachAsyncMultiError;

package/lib/helpers/cursor/eachAsync.js

@@ -4,6 +4,7 @@
  * Module dependencies.
  */
 
+const EachAsyncMultiError = require('../../error/eachAsyncMultiError');
 const immediate = require('../immediate');
 const promiseOrCallback = require('../promiseOrCallback');
 
@@ -24,10 +25,11 @@ const promiseOrCallback = require('../promiseOrCallback');
 module.exports = function eachAsync(next, fn, options, callback) {
   const parallel = options.parallel || 1;
   const batchSize = options.batchSize;
+  const continueOnError = options.continueOnError;
+  const aggregatedErrors = [];
   const enqueue = asyncQueue();
 
   return promiseOrCallback(callback, cb => {
-
     if (batchSize != null) {
       if (typeof batchSize !== 'number') {
         throw new TypeError('batchSize must be a number');
@@ -62,14 +64,22 @@ module.exports = function eachAsync(next, fn, options, callback) {
           return done();
         }
         if (err != null) {
-          error = err;
-          finalCallback(err);
-          return done();
+          if (continueOnError) {
+            aggregatedErrors.push(err);
+          } else {
+            error = err;
+            finalCallback(err);
+            return done();
+          }
         }
         if (doc == null) {
           drained = true;
           if (handleResultsInProgress <= 0) {
-            finalCallback(null);
+            const finalErr = continueOnError ?
+              createEachAsyncMultiError(aggregatedErrors) :
+              error;
+
+            finalCallback(finalErr);
           } else if (batchSize && documentsBatch.length) {
             handleNextResult(documentsBatch, currentDocumentIndex++, handleNextResultCallBack);
           }
@@ -102,11 +112,18 @@ module.exports = function eachAsync(next, fn, options, callback) {
             --handleResultsInProgress;
           }
           if (err != null) {
-            error = err;
-            return finalCallback(err);
+            if (continueOnError) {
+              aggregatedErrors.push(err);
+            } else {
+              error = err;
+              return finalCallback(err);
+            }
           }
           if (drained && handleResultsInProgress <= 0) {
-            return finalCallback(null);
+            const finalErr = continueOnError ?
+              createEachAsyncMultiError(aggregatedErrors) :
+              error;
+            return finalCallback(finalErr);
           }
 
           immediate(() => enqueue(fetch));
@@ -118,11 +135,18 @@ module.exports = function eachAsync(next, fn, options, callback) {
   }
 
   function handleNextResult(doc, i, callback) {
-    const promise = fn(doc, i);
-    if (promise && typeof promise.then === 'function') {
-      promise.then(
+    let maybePromise;
+    try {
+      maybePromise = fn(doc, i);
+    } catch (err) {
+      return callback(err);
+    }
+    if (maybePromise && typeof maybePromise.then === 'function') {
+      maybePromise.then(
         function() { callback(null); },
-        function(error) { callback(error || new Error('`eachAsync()` promise rejected without error')); });
+        function(error) {
+          callback(error || new Error('`eachAsync()` promise rejected without error'));
+        });
     } else {
       callback(null);
     }
@@ -158,3 +182,11 @@ function asyncQueue() {
     }
   }
 }
+
+function createEachAsyncMultiError(aggregatedErrors) {
+  if (aggregatedErrors.length === 0) {
+    return null;
+  }
+
+  return new EachAsyncMultiError(aggregatedErrors);
+}

package/lib/helpers/indexes/applySchemaCollation.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const isTextIndex = require('./isTextIndex');
+
+module.exports = function applySchemaCollation(indexKeys, indexOptions, schemaOptions) {
+  if (isTextIndex(indexKeys)) {
+    return;
+  }
+
+  if (schemaOptions.hasOwnProperty('collation') && !indexOptions.hasOwnProperty('collation')) {
+    indexOptions.collation = schemaOptions.collation;
+  }
+};

package/lib/helpers/indexes/isTextIndex.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Returns `true` if the given index options have a `text` option.
+ */
+
+module.exports = function isTextIndex(indexKeys) {
+  let isTextIndex = false;
+  for (const key of Object.keys(indexKeys)) {
+    if (indexKeys[key] === 'text') {
+      isTextIndex = true;
+    }
+  }
+
+  return isTextIndex;
+};

package/lib/helpers/model/discriminator.js

@@ -17,7 +17,6 @@ const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
  */
 
 module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins) {
-
   if (!(schema && schema.instanceOfSchema)) {
     throw new Error('You must pass a valid discriminator Schema');
   }
@@ -109,7 +108,7 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
 
     utils.merge(schema, baseSchema, {
       isDiscriminatorSchemaMerge: true,
-      omit: { discriminators: true, base: true },
+      omit: { discriminators: true, base: true, _applyDiscriminators: true },
       omitNested: conflictingPaths.reduce((cur, path) => {
         cur['tree.' + path] = true;
         return cur;
@@ -141,7 +140,6 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
     obj[key][schema.options.typeKey] = existingPath ? existingPath.options[schema.options.typeKey] : String;
     schema.add(obj);
 
-
     schema.discriminatorMapping = { key: key, value: value, isRoot: false };
 
     if (baseSchema.options.collection) {

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -76,17 +76,20 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     let schemaOptions = null;
     let modelNamesInOrder = null;
 
-    if (schema != null && schema.instance === 'Embedded' && schema.options.ref) {
-      const data = {
-        localField: options.path + '._id',
-        foreignField: '_id',
-        justOne: true
-      };
-      const res = _getModelNames(doc, schema, modelNameFromQuery, model);
+    if (schema != null && schema.instance === 'Embedded') {
+      if (schema.options.ref) {
+        const data = {
+          localField: options.path + '._id',
+          foreignField: '_id',
+          justOne: true
+        };
+        const res = _getModelNames(doc, schema, modelNameFromQuery, model);
 
-      const unpopulatedValue = mpath.get(options.path, doc);
-      const id = mpath.get('_id', unpopulatedValue);
-      addModelNamesToMap(model, map, available, res.modelNames, options, data, id, doc, schemaOptions, unpopulatedValue);
+        const unpopulatedValue = mpath.get(options.path, doc);
+        const id = mpath.get('_id', unpopulatedValue);
+        addModelNamesToMap(model, map, available, res.modelNames, options, data, id, doc, schemaOptions, unpopulatedValue);
+      }
+      // No-op if no `ref` set. See gh-11538
       continue;
     }
 

package/lib/helpers/query/applyGlobalOption.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const utils = require('../../utils');
+
+function applyGlobalMaxTimeMS(options, model) {
+  applyGlobalOption(options, model, 'maxTimeMS');
+}
+
+function applyGlobalDiskUse(options, model) {
+  applyGlobalOption(options, model, 'allowDiskUse');
+}
+
+module.exports = {
+  applyGlobalMaxTimeMS,
+  applyGlobalDiskUse
+};
+
+
+function applyGlobalOption(options, model, optionName) {
+  if (utils.hasUserDefinedProperty(options, optionName)) {
+    return;
+  }
+
+  if (utils.hasUserDefinedProperty(model.db.options, optionName)) {
+    options[optionName] = model.db.options[optionName];
+  } else if (utils.hasUserDefinedProperty(model.base.options, optionName)) {
+    options[optionName] = model.base.options[optionName];
+  }
+}

package/lib/helpers/query/castUpdate.js

@@ -47,7 +47,7 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
   } else if (!options.overwriteDiscriminatorKey) {
     delete obj[schema.options.discriminatorKey];
   }
-  if (options.upsert) {
+  if (options.upsert && !options.overwrite) {
     moveImmutableProperties(schema, obj, context);
   }
 
@@ -217,6 +217,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
       }
 
       if (op !== '$setOnInsert' &&
+          !options.overwrite &&
           handleImmutable(schematype, strict, obj, key, prefix + key, context)) {
         continue;
       }
@@ -311,6 +312,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, pref) {
 
       // You can use `$setOnInsert` with immutable keys
       if (op !== '$setOnInsert' &&
+          !options.overwrite &&
           handleImmutable(schematype, strict, obj, key, prefix + key, context)) {
         continue;
       }