mongoose 6.6.7 → 6.7.0

package/lib/aggregate.js

@@ -111,11 +111,11 @@ Aggregate.prototype.model = function(model) {
   this._model = model;
   if (model.schema != null) {
     if (this.options.readPreference == null &&
-        model.schema.options.read != null) {
+      model.schema.options.read != null) {
       this.options.readPreference = model.schema.options.read;
     }
     if (this.options.collation == null &&
-        model.schema.options.collation != null) {
+      model.schema.options.collation != null) {
       this.options.collation = model.schema.options.collation;
     }
   }
@@ -158,7 +158,7 @@ Aggregate.prototype.append = function() {
  * Requires MongoDB v3.4+ to work
  *
  * #### Example:
-  *
+ *
  *     // adding new fields based on existing fields
  *     aggregate.addFields({
  *         newField: '$b.nested'
@@ -328,6 +328,28 @@ Aggregate.prototype.project = function(arg) {
  * @api public
  */
 
+/**
+ * Appends a new $fill operator to this aggregate pipeline.
+ *
+ * #### Example:
+ *
+ *      aggregate.fill({
+ *        output: {
+ *          bootsSold: { value: 0 },
+ *          sandalsSold: { value: 0 },
+ *          sneakersSold: { value: 0 }
+ *        }
+ *      });
+ *
+ * @see $fill https://www.mongodb.com/docs/manual/reference/operator/aggregation/fill/
+ * @method fill
+ * @memberOf Aggregate
+ * @instance
+ * @param {Object} arg $fill operator contents
+ * @return {Aggregate}
+ * @api public
+ */
+
 /**
  * Appends a new $geoNear operator to this aggregate pipeline.
  *
@@ -366,7 +388,7 @@ Aggregate.prototype.near = function(arg) {
  * define methods
  */
 
-'group match skip limit out densify'.split(' ').forEach(function($operator) {
+'group match skip limit out densify fill'.split(' ').forEach(function($operator) {
   Aggregate.prototype[$operator] = function(arg) {
     const op = {};
     op['$' + $operator] = arg;
@@ -702,7 +724,7 @@ Aggregate.prototype.readConcern = function(level) {
 Aggregate.prototype.redact = function(expression, thenExpr, elseExpr) {
   if (arguments.length === 3) {
     if ((typeof thenExpr === 'string' && !validRedactStringValues.has(thenExpr)) ||
-        (typeof elseExpr === 'string' && !validRedactStringValues.has(elseExpr))) {
+      (typeof elseExpr === 'string' && !validRedactStringValues.has(elseExpr))) {
       throw new Error('If thenExpr or elseExpr is string, it must be either $$DESCEND, $$PRUNE or $$KEEP');
     }
 
@@ -1099,9 +1121,7 @@ Aggregate.prototype.catch = function(reject) {
 
 if (Symbol.asyncIterator != null) {
   Aggregate.prototype[Symbol.asyncIterator] = function() {
-    return this.cursor({ useMongooseAggCursor: true }).
-      transformNull().
-      _transformForAsyncIterator();
+    return this.cursor({ useMongooseAggCursor: true }).transformNull()._transformForAsyncIterator();
   };
 }
 

package/lib/document.js

@@ -948,6 +948,48 @@ Document.prototype.$session = function $session(session) {
   return session;
 };
 
+/**
+ * Getter/setter around whether this document will apply timestamps by
+ * default when using `save()` and `bulkSave()`.
+ *
+ * #### Example:
+ *
+ *     const TestModel = mongoose.model('Test', new Schema({ name: String }, { timestamps: true }));
+ *     const doc = new TestModel({ name: 'John Smith' });
+ *
+ *     doc.$timestamps(); // true
+ *
+ *     doc.$timestamps(false);
+ *     await doc.save(); // Does **not** apply timestamps
+ *
+ * @param {Boolean} [value] overwrite the current session
+ * @return {Document|boolean|undefined} When used as a getter (no argument), a boolean will be returned indicating the timestamps option state or if unset "undefined" will be used, otherwise will return "this"
+ * @method $timestamps
+ * @api public
+ * @memberOf Document
+ */
+
+Document.prototype.$timestamps = function $timestamps(value) {
+  if (arguments.length === 0) {
+    if (this.$__.timestamps != null) {
+      return this.$__.timestamps;
+    }
+
+    if (this.$__schema) {
+      return this.$__schema.options.timestamps;
+    }
+
+    return undefined;
+  }
+
+  const currentValue = this.$timestamps();
+  if (value !== currentValue) {
+    this.$__.timestamps = value;
+  }
+
+  return this;
+};
+
 /**
  * Overwrite all values in this document with the values of `obj`, except
  * for immutable properties. Behaves similarly to `set()`, except for it

package/lib/error/setOptionError.js

@@ -0,0 +1,101 @@
+/*!
+ * Module requirements
+ */
+
+'use strict';
+
+const MongooseError = require('./mongooseError');
+const util = require('util');
+const combinePathErrors = require('../helpers/error/combinePathErrors');
+
+class SetOptionError extends MongooseError {
+  /**
+   * Mongoose.set Error
+   *
+   * @api private
+   * @inherits MongooseError
+   */
+  constructor() {
+    super('');
+
+    this.errors = {};
+  }
+
+  /**
+   * Console.log helper
+   */
+  toString() {
+    return combinePathErrors(this);
+  }
+
+  /**
+   * inspect helper
+   * @api private
+   */
+  inspect() {
+    return Object.assign(new Error(this.message), this);
+  }
+
+  /**
+  * add message
+  * @param {String} key
+  * @param {String|Error} error
+  * @api private
+  */
+  addError(key, error) {
+    if (error instanceof SetOptionError) {
+      const { errors } = error;
+      for (const optionKey of Object.keys(errors)) {
+        this.addError(optionKey, errors[optionKey]);
+      }
+
+      return;
+    }
+
+    this.errors[key] = error;
+    this.message = combinePathErrors(this);
+  }
+}
+
+
+if (util.inspect.custom) {
+  // Avoid Node deprecation warning DEP0079
+  SetOptionError.prototype[util.inspect.custom] = SetOptionError.prototype.inspect;
+}
+
+/**
+ * Helper for JSON.stringify
+ * Ensure `name` and `message` show up in toJSON output re: gh-9847
+ * @api private
+ */
+Object.defineProperty(SetOptionError.prototype, 'toJSON', {
+  enumerable: false,
+  writable: false,
+  configurable: true,
+  value: function() {
+    return Object.assign({}, this, { name: this.name, message: this.message });
+  }
+});
+
+
+Object.defineProperty(SetOptionError.prototype, 'name', {
+  value: 'SetOptionError'
+});
+
+class SetOptionInnerError extends MongooseError {
+  /**
+   * Error for the "errors" array in "SetOptionError" with consistent message
+   * @param {String} key
+   */
+  constructor(key) {
+    super(`"${key}" is not a valid option to set`);
+  }
+}
+
+SetOptionError.SetOptionInnerError = SetOptionInnerError;
+
+/*!
+ * Module exports
+ */
+
+module.exports = SetOptionError;

package/lib/error/validation.js

@@ -7,6 +7,7 @@
 const MongooseError = require('./mongooseError');
 const getConstructorName = require('../helpers/getConstructorName');
 const util = require('util');
+const combinePathErrors = require('../helpers/error/combinePathErrors');
 
 class ValidationError extends MongooseError {
   /**
@@ -38,7 +39,7 @@ class ValidationError extends MongooseError {
    * Console.log helper
    */
   toString() {
-    return this.name + ': ' + _generateMessage(this);
+    return this.name + ': ' + combinePathErrors(this);
   }
 
   /**
@@ -66,7 +67,7 @@ class ValidationError extends MongooseError {
     }
 
     this.errors[path] = error;
-    this.message = this._message + ': ' + _generateMessage(this);
+    this.message = this._message + ': ' + combinePathErrors(this);
   }
 }
 
@@ -95,27 +96,6 @@ Object.defineProperty(ValidationError.prototype, 'name', {
   value: 'ValidationError'
 });
 
-/*!
- * ignore
- */
-
-function _generateMessage(err) {
-  const keys = Object.keys(err.errors || {});
-  const len = keys.length;
-  const msgs = [];
-  let key;
-
-  for (let i = 0; i < len; ++i) {
-    key = keys[i];
-    if (err === err.errors[key]) {
-      continue;
-    }
-    msgs.push(key + ': ' + err.errors[key].message);
-  }
-
-  return msgs.join(', ');
-}
-
 /*!
  * Module exports
  */

package/lib/helpers/error/combinePathErrors.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+module.exports = function combinePathErrors(err) {
+  const keys = Object.keys(err.errors || {});
+  const len = keys.length;
+  const msgs = [];
+  let key;
+
+  for (let i = 0; i < len; ++i) {
+    key = keys[i];
+    if (err === err.errors[key]) {
+      continue;
+    }
+    msgs.push(key + ': ' + err.errors[key].message);
+  }
+
+  return msgs.join(', ');
+};

package/lib/helpers/model/discriminator.js

@@ -19,11 +19,13 @@ const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
  * ignore
  */
 
-module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins) {
+module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins, mergeHooks) {
   if (!(schema && schema.instanceOfSchema)) {
     throw new Error('You must pass a valid discriminator Schema');
   }
 
+  mergeHooks = mergeHooks == null ? true : mergeHooks;
+
   if (model.schema.discriminatorMapping &&
       !model.schema.discriminatorMapping.isRoot) {
     throw new Error('Discriminator "' + name +
@@ -32,7 +34,7 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
 
   if (applyPlugins) {
     const applyPluginsToDiscriminators = get(model.base,
-      'options.applyPluginsToDiscriminators', false);
+      'options.applyPluginsToDiscriminators', false) || !mergeHooks;
     // Even if `applyPluginsToDiscriminators` isn't set, we should still apply
     // global plugins to schemas embedded in the discriminator schema (gh-7370)
     model.base._applyPlugins(schema, {
@@ -179,7 +181,9 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
       schema.options._id = _id;
     }
     schema.options.id = id;
-    schema.s.hooks = model.schema.s.hooks.merge(schema.s.hooks);
+    if (mergeHooks) {
+      schema.s.hooks = model.schema.s.hooks.merge(schema.s.hooks);
+    }
 
     schema.plugins = Array.prototype.slice.call(baseSchema.plugins);
     schema.callQueue = baseSchema.callQueue.concat(schema.callQueue);

package/lib/index.js

@@ -37,6 +37,7 @@ const trusted = require('./helpers/query/trusted').trusted;
 const sanitizeFilter = require('./helpers/query/sanitizeFilter');
 const isBsonType = require('./helpers/isBsonType');
 const MongooseError = require('./error/mongooseError');
+const SetOptionError = require('./error/setOptionError');
 
 const defaultMongooseSymbol = Symbol.for('mongoose:default');
 
@@ -182,6 +183,9 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
 /**
  * Sets mongoose options
  *
+ * `key` can be used a object to set multiple options at once.
+ * If a error gets thrown for one option, other options will still be evaluated.
+ *
  * #### Example:
  *
  *     mongoose.set('test', value) // sets the 'test' option to `value`
@@ -190,6 +194,8 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
  *
  *     mongoose.set('debug', function(collectionName, methodName, ...methodArgs) {}); // use custom function to log collection methods + arguments
  *
+ *     mongoose.set({ debug: true, autoIndex: false }); // set multiple options at once
+ *
  * Currently supported options are:
  * - 'applyPluginsToChildSchemas': `true` by default. Set to false to skip applying global plugins to child schemas
  * - 'applyPluginsToDiscriminators': `false` by default. Set to true to apply global plugins to discriminator schemas. This typically isn't necessary because plugins are applied to the base schema and discriminators copy all middleware, methods, statics, and properties from the base schema.
@@ -213,36 +219,66 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
  * - 'toJSON': `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toJSON()`](/docs/api.html#document_Document-toJSON), for determining how Mongoose documents get serialized by `JSON.stringify()`
  * - 'toObject': `{ transform: true, flattenDecimals: true }` by default. Overwrites default objects to [`toObject()`](/docs/api.html#document_Document-toObject)
  *
- * @param {String} key
- * @param {String|Function|Boolean} value
+ * @param {String|Object} key The name of the option or a object of multiple key-value pairs
+ * @param {String|Function|Boolean} value The value of the option, unused if "key" is a object
+ * @returns {Mongoose} The used Mongoose instnace
  * @api public
  */
 
 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 (arguments.length === 1 && typeof key !== 'object') {
+    if (VALID_OPTIONS.indexOf(key) === -1) {
+      const error = new SetOptionError();
+      error.addError(key, new SetOptionError.SetOptionInnerError(key));
+      throw error;
+    }
 
-  if (arguments.length === 1) {
     return _mongoose.options[key];
   }
 
-  _mongoose.options[key] = value;
+  let options = {};
 
-  if (key === 'objectIdGetter') {
-    if (value) {
-      Object.defineProperty(mongoose.Types.ObjectId.prototype, '_id', {
-        enumerable: false,
-        configurable: true,
-        get: function() {
-          return this;
-        }
-      });
-    } else {
-      delete mongoose.Types.ObjectId.prototype._id;
+  if (arguments.length === 2) {
+    options = { [key]: value };
+  }
+
+  if (arguments.length === 1 && typeof key === 'object') {
+    options = key;
+  }
+
+  // array for errors to collect all errors for all key-value pairs, like ".validate"
+  let error = undefined;
+
+  for (const [optionKey, optionValue] of Object.entries(options)) {
+    if (VALID_OPTIONS.indexOf(optionKey) === -1) {
+      if (!error) {
+        error = new SetOptionError();
+      }
+      error.addError(optionKey, new SetOptionError.SetOptionInnerError(optionKey));
+      continue;
     }
+
+    _mongoose.options[optionKey] = optionValue;
+
+    if (optionKey === 'objectIdGetter') {
+      if (optionValue) {
+        Object.defineProperty(mongoose.Types.ObjectId.prototype, '_id', {
+          enumerable: false,
+          configurable: true,
+          get: function() {
+            return this;
+          }
+        });
+      } else {
+        delete mongoose.Types.ObjectId.prototype._id;
+      }
+    }
+  }
+
+  if (error) {
+    throw error;
   }
 
   return _mongoose;

package/lib/model.js

@@ -511,6 +511,9 @@ Model.prototype.save = function(options, fn) {
   if (options.hasOwnProperty('session')) {
     this.$session(options.session);
   }
+  if (this.$__.timestamps != null) {
+    options.timestamps = this.$__.timestamps;
+  }
   this.$__.$versionError = generateVersionError(this, this.modifiedPaths());
 
   fn = this.constructor.$handleCallbackError(fn);
@@ -1211,6 +1214,7 @@ Model.exists = function exists(filter, options, callback) {
  * @param {String} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
  * @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
  * @param {Boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
+ * @param {Boolean} [options.mergeHooks=true] By default, Mongoose merges the base schema's hooks with the discriminator schema's hooks. Set this option to `false` to make Mongoose use the discriminator schema's hooks instead.
  * @return {Model} The newly created discriminator model
  * @api public
  */
@@ -1238,7 +1242,7 @@ Model.discriminator = function(name, schema, options) {
     schema = schema.clone();
   }
 
-  schema = discriminator(this, name, schema, value, true);
+  schema = discriminator(this, name, schema, value, true, options.mergeHooks);
   if (this.db.models[name] && !schema.options.overwriteModels) {
     throw new OverwriteModelError(name);
   }
@@ -3455,7 +3459,8 @@ Model.$__insertMany = function(arr, options, callback) {
       if (doc.$__schema.options.versionKey) {
         doc[doc.$__schema.options.versionKey] = 0;
       }
-      if ((!options || options.timestamps !== false) && doc.initializeTimestamps) {
+      const shouldSetTimestamps = (!options || options.timestamps !== false) && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
+      if (shouldSetTimestamps) {
         return doc.initializeTimestamps().toObject(internalToObjectOptions);
       }
       return doc.toObject(internalToObjectOptions);
@@ -3696,6 +3701,13 @@ Model.bulkSave = async function(documents, options) {
       document.$__.saveOptions = document.$__.saveOptions || {};
       document.$__.saveOptions.timestamps = options.timestamps;
     }
+  } else {
+    for (const document of documents) {
+      if (document.$__.timestamps != null) {
+        document.$__.saveOptions = document.$__.saveOptions || {};
+        document.$__.saveOptions.timestamps = document.$__.timestamps;
+      }
+    }
   }
 
   await Promise.all(documents.map(buildPreSavePromise));

package/lib/schema/index.js

@@ -29,6 +29,8 @@ exports.Decimal128 = exports.Decimal = require('./decimal128');
 
 exports.Map = require('./map');
 
+exports.UUID = require('./uuid');
+
 // alias
 
 exports.Oid = exports.ObjectId;