mongoose 6.2.11 → 6.3.0

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.
@@ -672,8 +674,6 @@ Aggregate.prototype.readConcern = function(level) {
  * @api public
  */
 
-const validRedactStringValues = new Set(['$$DESCEND', '$$PRUNE', '$$KEEP']);
-
 Aggregate.prototype.redact = function(expression, thenExpr, elseExpr) {
   if (arguments.length === 3) {
     if ((typeof thenExpr === 'string' && !validRedactStringValues.has(thenExpr)) ||
@@ -973,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/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/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/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/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/index.js

@@ -179,7 +179,9 @@ Mongoose.prototype.driver = driver;
 Mongoose.prototype.set = function(key, value) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
-  if (VALID_OPTIONS.indexOf(key) === -1) throw new Error(`\`${key}\` is an invalid option.`);
+  if (VALID_OPTIONS.indexOf(key) === -1) {
+    throw new Error(`\`${key}\` is an invalid option.`);
+  }
 
   if (arguments.length === 1) {
     return _mongoose.options[key];
@@ -467,6 +469,7 @@ Mongoose.prototype.pluralize = function(fn) {
  */
 
 Mongoose.prototype.model = function(name, schema, collection, options) {
+
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   if (typeof schema === 'string') {
@@ -519,7 +522,6 @@ Mongoose.prototype.model = function(name, schema, collection, options) {
   }
 
   const model = _mongoose._model(name, schema, collection, options);
-
   _mongoose.connection.models[name] = model;
   _mongoose.models[name] = model;
 
@@ -561,12 +563,17 @@ Mongoose.prototype._model = function(name, schema, collection, options) {
 
   const connection = options.connection || _mongoose.connection;
   model = _mongoose.Model.compile(model || name, schema, collection, connection, _mongoose);
-
   // Errors handled internally, so safe to ignore error
   model.init(function $modelInitNoop() {});
 
   connection.emit('model', model);
 
+  if (schema._applyDiscriminators != null) {
+    for (const disc of Object.keys(schema._applyDiscriminators)) {
+      model.discriminator(disc, schema._applyDiscriminators[disc]);
+    }
+  }
+
   return model;
 };
 

package/lib/model.js

@@ -4212,7 +4212,6 @@ Model.aggregate = function aggregate(pipeline, options, callback) {
 
   const aggregate = new Aggregate(pipeline || []);
   aggregate.model(this);
-
   if (options != null) {
     aggregate.option(options);
   }
@@ -4809,7 +4808,6 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
     o[schema.options.versionKey] = Number;
     schema.add(o);
   }
-
   let model;
   if (typeof name === 'function' && name.prototype instanceof Model) {
     model = name;
@@ -4853,6 +4851,7 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   model.model = function model(name) {
     return this.db.model(name);
   };
+
   model.db = connection;
   model.prototype.db = connection;
   model.prototype[modelDbSymbol] = connection;

package/lib/query.js

@@ -12,7 +12,7 @@ const ObjectParameterError = require('./error/objectParameter');
 const QueryCursor = require('./cursor/QueryCursor');
 const ReadPreference = require('./driver').get().ReadPreference;
 const ValidationError = require('./error/validation');
-const applyGlobalMaxTimeMS = require('./helpers/query/applyGlobalMaxTimeMS');
+const { applyGlobalMaxTimeMS, applyGlobalDiskUse } = require('./helpers/query/applyGlobalOption');
 const applyWriteConcern = require('./helpers/schema/applyWriteConcern');
 const cast = require('./cast');
 const castArrayFilters = require('./helpers/update/castArrayFilters');
@@ -2192,6 +2192,7 @@ function _castArrayFilters(query) {
  * @api private
  */
 Query.prototype._find = wrapThunk(function(callback) {
+
   this._castConditions();
 
   if (this.error() != null) {
@@ -2210,6 +2211,7 @@ Query.prototype._find = wrapThunk(function(callback) {
   const userProvidedFields = _this._userProvidedFields || {};
 
   applyGlobalMaxTimeMS(this.options, this.model);
+  applyGlobalDiskUse(this.options, this.model);
 
   // Separate options to pass down to `completeMany()` in case we need to
   // set a session on the document
@@ -2228,8 +2230,15 @@ Query.prototype._find = wrapThunk(function(callback) {
     if (this.options.explain) {
       return callback(null, docs);
     }
-
     if (!mongooseOptions.populate) {
+      const versionKey = _this.schema.options.versionKey;
+      if (mongooseOptions.lean && mongooseOptions.lean.versionKey === false && versionKey) {
+        docs.forEach((doc) => {
+          if (versionKey in doc) {
+            delete doc[versionKey];
+          }
+        });
+      }
       return mongooseOptions.lean ?
         callback(null, docs) :
         completeMany(_this.model, docs, fields, userProvidedFields, completeManyOptions, callback);
@@ -2411,6 +2420,12 @@ Query.prototype._completeOne = function(doc, res, callback) {
   }
 
   if (!mongooseOptions.populate) {
+    const versionKey = this.schema.options.versionKey;
+    if (mongooseOptions.lean && mongooseOptions.lean.versionKey === false && versionKey) {
+      if (versionKey in doc) {
+        delete doc[versionKey];
+      }
+    }
     return mongooseOptions.lean ?
       _completeOneLean(doc, res, options, callback) :
       completeOne(model, doc, res, options, projection, userProvidedFields,
@@ -2453,8 +2468,8 @@ Query.prototype._findOne = wrapThunk(function(callback) {
 
   this._applyPaths();
   this._fields = this._castFields(this._fields);
-
   applyGlobalMaxTimeMS(this.options, this.model);
+  applyGlobalDiskUse(this.options, this.model);
 
   // don't pass in the conditions because we already merged them in
   Query.base.findOne.call(this, {}, (err, doc) => {
@@ -2567,6 +2582,7 @@ Query.prototype._count = wrapThunk(function(callback) {
   }
 
   applyGlobalMaxTimeMS(this.options, this.model);
+  applyGlobalDiskUse(this.options, this.model);
 
   const conds = this._conditions;
   const options = this._optionsForExec();
@@ -2594,6 +2610,7 @@ Query.prototype._countDocuments = wrapThunk(function(callback) {
   }
 
   applyGlobalMaxTimeMS(this.options, this.model);
+  applyGlobalDiskUse(this.options, this.model);
 
   const conds = this._conditions;
   const options = this._optionsForExec();
@@ -2814,6 +2831,7 @@ Query.prototype.__distinct = wrapThunk(function __distinct(callback) {
   }
 
   applyGlobalMaxTimeMS(this.options, this.model);
+  applyGlobalDiskUse(this.options, this.model);
 
   const options = this._optionsForExec();
 

package/lib/schema.js

@@ -22,6 +22,7 @@ const readPref = require('./driver').get().ReadPreference;
 const setupTimestamps = require('./helpers/timestamps/setupTimestamps');
 const utils = require('./utils');
 const validateRef = require('./helpers/populate/validateRef');
+const util = require('util');
 
 let MongooseTypes;
 
@@ -370,6 +371,9 @@ Schema.prototype._clone = function _clone(Constructor) {
   if (this.discriminators != null) {
     s.discriminators = Object.assign({}, this.discriminators);
   }
+  if (this._applyDiscriminators != null) {
+    s._applyDiscriminators = Object.assign({}, this._applyDiscriminators);
+  }
 
   s.aliases = Object.assign({}, this.aliases);
 
@@ -469,6 +473,11 @@ Schema.prototype.defaultOptions = function(options) {
   return options;
 };
 
+Schema.prototype.discriminator = function(name, schema) {
+  this._applyDiscriminators = {};
+  this._applyDiscriminators[name] = schema;
+};
+
 /**
  * Adds key path / schema type pairs to this schema.
  *
@@ -510,7 +519,6 @@ Schema.prototype.add = function add(obj, prefix) {
 
   const keys = Object.keys(obj);
   const typeKey = this.options.typeKey;
-
   for (const key of keys) {
     const fullPath = prefix + key;
     const val = obj[key];
@@ -540,6 +548,25 @@ Schema.prototype.add = function add(obj, prefix) {
         this.nested[prefix.substring(0, prefix.length - 1)] = true;
       }
       this.path(prefix + key, val);
+      if (val[0] != null && !(val[0].instanceOfSchema) && utils.isPOJO(val[0].discriminators)) {
+        const schemaType = this.path(prefix + key);
+        for (const key in val[0].discriminators) {
+          schemaType.discriminator(key, val[0].discriminators[key]);
+        }
+      } else if (val[0] != null && val[0].instanceOfSchema && utils.isPOJO(val[0]._applyDiscriminators)) {
+        const applyDiscriminators = val[0]._applyDiscriminators || [];
+        const schemaType = this.path(prefix + key);
+        for (const disc in applyDiscriminators) {
+          schemaType.discriminator(disc, applyDiscriminators[disc]);
+        }
+      }
+      else if (val != null && val.instanceOfSchema && utils.isPOJO(val._applyDiscriminators)) {
+        const applyDiscriminators = val._applyDiscriminators || [];
+        const schemaType = this.path(prefix + key);
+        for (const disc in applyDiscriminators) {
+          schemaType.discriminator(disc, applyDiscriminators[disc]);
+        }
+      }
     } else if (Object.keys(val).length < 1) {
       // Special-case: {} always interpreted as Mixed path so leaf at this node
       if (prefix) {
@@ -569,6 +596,12 @@ Schema.prototype.add = function add(obj, prefix) {
           this.nested[prefix.substring(0, prefix.length - 1)] = true;
         }
         this.path(prefix + key, val);
+        if (val != null && !(val.instanceOfSchema) && utils.isPOJO(val.discriminators)) {
+          const schemaType = this.path(prefix + key);
+          for (const key in val.discriminators) {
+            schemaType.discriminator(key, val.discriminators[key]);
+          }
+        }
       }
     }
   }
@@ -579,6 +612,86 @@ Schema.prototype.add = function add(obj, prefix) {
   return this;
 };
 
+/**
+ * Remove an index by name or index specification.
+ *
+ * removeIndex only removes indexes from your schema object. Does **not** affect the indexes
+ * in MongoDB.
+ *
+ * ####Example:
+ *
+ *     const ToySchema = new Schema({ name: String, color: String, price: Number });
+ *
+ *     // Add a new index on { name, color }
+ *     ToySchema.index({ name: 1, color: 1 });
+ *
+ *     // Remove index on { name, color }
+ *     // Keep in mind that order matters! `removeIndex({ color: 1, name: 1 })` won't remove the index
+ *     ToySchema.removeIndex({ name: 1, color: 1 });
+ *
+ *     // Add an index with a custom name
+ *     ToySchema.index({ color: 1 }, { name: 'my custom index name' });
+ *     // Remove index by name
+ *     ToySchema.removeIndex('my custom index name');
+ *
+ * @param {Object|string} index name or index specification
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
+Schema.prototype.removeIndex = function removeIndex(index) {
+  if (arguments.length > 1) {
+    throw new Error('removeIndex() takes only 1 argument');
+  }
+
+  if (typeof index !== 'object' && typeof index !== 'string') {
+    throw new Error('removeIndex() may only take either an object or a string as an argument');
+  }
+
+  if (typeof index === 'object') {
+    for (let i = this._indexes.length - 1; i >= 0; --i) {
+      if (util.isDeepStrictEqual(this._indexes[i][0], index)) {
+        this._indexes.splice(i, 1);
+      }
+    }
+  } else {
+    for (let i = this._indexes.length - 1; i >= 0; --i) {
+      if (this._indexes[i][1] != null && this._indexes[i][1].name === index) {
+        this._indexes.splice(i, 1);
+      }
+    }
+  }
+
+  return this;
+};
+
+/**
+ * Remove all indexes from this schema.
+ *
+ * clearIndexes only removes indexes from your schema object. Does **not** affect the indexes
+ * in MongoDB.
+ *
+ * ####Example:
+ *
+ *     const ToySchema = new Schema({ name: String, color: String, price: Number });
+ *     ToySchema.index({ name: 1 });
+ *     ToySchema.index({ color: 1 });
+ *
+ *     // Remove all indexes on this schema
+ *     ToySchema.clearIndexes();
+ *
+ *     ToySchema.indexes(); // []
+ *
+ * @return {Schema} the Schema instance
+ * @api public
+ */
+
+Schema.prototype.clearIndexes = function clearIndexes() {
+  this._indexes.length = 0;
+
+  return this;
+};
+
 /**
  * Reserved document keys.
  *

package/lib/validoptions.js

@@ -6,6 +6,7 @@
 'use strict';
 
 const VALID_OPTIONS = Object.freeze([
+  'allowDiskUse',
   'applyPluginsToChildSchemas',
   'applyPluginsToDiscriminators',
   'autoCreate',