mongoose 6.2.10 → 6.3.1

package/lib/helpers/schematype/handleImmutable.js

@@ -19,13 +19,16 @@ module.exports = function(schematype) {
 };
 
 function createImmutableSetter(path, immutable) {
-  return function immutableSetter(v) {
+  return function immutableSetter(v, _priorVal, _doc, options) {
     if (this == null || this.$__ == null) {
       return v;
     }
     if (this.isNew) {
       return v;
     }
+    if (options && options.overwriteImmutable) {
+      return v;
+    }
 
     const _immutable = typeof immutable === 'function' ?
       immutable.call(this, this) :

package/lib/helpers/timestamps/setupTimestamps.js

@@ -48,8 +48,8 @@ module.exports = function setupTimestamps(schema, timestamps) {
       currentTime() :
       this.ownerDocument().constructor.base.now();
 
-    if (!skipCreatedAt && this.isNew && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
-      this.$set(createdAt, defaultTimestamp);
+    if (!skipCreatedAt && (this.isNew || this.$isSubdocument) && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
+      this.$set(createdAt, defaultTimestamp, undefined, { overwriteImmutable: true });
     }
 
     if (!skipUpdatedAt && updatedAt && (this.isNew || this.$isModified())) {

package/lib/helpers/update/applyTimestampsToChildren.js

@@ -15,7 +15,7 @@ function applyTimestampsToChildren(now, update, schema) {
   }
 
   const keys = Object.keys(update);
-  const hasDollarKey = keys.some(key => key.startsWith('$'));
+  const hasDollarKey = keys.some(key => key[0] === '$');
 
   if (hasDollarKey) {
     if (update.$push) {
@@ -38,7 +38,7 @@ function applyTimestampsToChildren(now, update, schema) {
     }
   }
 
-  const updateKeys = Object.keys(update).filter(key => !key.startsWith('$'));
+  const updateKeys = Object.keys(update).filter(key => key[0] !== '$');
   for (const key of updateKeys) {
     applyTimestampsToUpdateKey(schema, key, update, now);
   }

package/lib/helpers/update/applyTimestampsToUpdate.js

@@ -80,7 +80,6 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
   }
 
   if (!skipCreatedAt && createdAt) {
-
     if (currentUpdate[createdAt]) {
       delete currentUpdate[createdAt];
     }

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];
@@ -265,7 +267,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {Number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
- * @return {Connection} the created Connection object. Connections are thenable, so you can do `await mongoose.createConnection()`
+ * @return {Connection} the created Connection object. Connections are not thenable, so you can not `await mongoose.createConnection()`. To await use mongoose.createConnection(uri).asPromise() instead.
  * @api public
  */
 
@@ -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

@@ -26,6 +26,7 @@ const applyQueryMiddleware = require('./helpers/query/applyQueryMiddleware');
 const applyHooks = require('./helpers/model/applyHooks');
 const applyMethods = require('./helpers/model/applyMethods');
 const applyProjection = require('./helpers/projection/applyProjection');
+const applySchemaCollation = require('./helpers/indexes/applySchemaCollation');
 const applyStaticHooks = require('./helpers/model/applyStaticHooks');
 const applyStatics = require('./helpers/model/applyStatics');
 const applyWriteConcern = require('./helpers/schema/applyWriteConcern');
@@ -1073,6 +1074,22 @@ Model.prototype.model = function model(name) {
   return this[modelDbSymbol].model(name);
 };
 
+/**
+ * Returns another Model instance.
+ *
+ * #### Example:
+ *
+ *     const doc = new Tank;
+ *     doc.model('User').findById(id, callback);
+ *
+ * @param {String} name model name
+ * @api public
+ */
+
+Model.prototype.$model = function $model(name) {
+  return this[modelDbSymbol].model(name);
+};
+
 /**
  * Returns a document with `_id` only if at least one document exists in the database that matches
  * the given `filter`, and `null` otherwise.
@@ -1361,23 +1378,27 @@ Model.createCollection = function createCollection(options, callback) {
   }
 
   const schemaCollation = this &&
-  this.schema &&
-  this.schema.options &&
-  this.schema.options.collation || null;
+    this.schema &&
+    this.schema.options &&
+    this.schema.options.collation;
   if (schemaCollation != null) {
     options = Object.assign({ collation: schemaCollation }, options);
   }
   const capped = this &&
-  this.schema &&
-  this.schema.options &&
-   this.schema.options.capped;
-  if (capped) {
-    options = Object.assign({ capped: true }, capped, options);
+    this.schema &&
+    this.schema.options &&
+    this.schema.options.capped;
+  if (capped != null) {
+    if (typeof capped === 'number') {
+      options = Object.assign({ capped: true, size: capped }, options);
+    } else if (typeof capped === 'object') {
+      options = Object.assign({ capped: true }, capped, options);
+    }
   }
   const timeseries = this &&
-  this.schema &&
-  this.schema.options &&
-  this.schema.options.timeseries;
+    this.schema &&
+    this.schema.options &&
+    this.schema.options.timeseries;
   if (timeseries != null) {
     options = Object.assign({ timeseries }, options);
     if (options.expireAfterSeconds != null) {
@@ -1562,6 +1583,7 @@ Model.cleanIndexes = function cleanIndexes(callback) {
 
         for (const [schemaIndexKeysObject, schemaIndexOptions] of schemaIndexes) {
           const options = decorateDiscriminatorIndexOptions(this.schema, utils.clone(schemaIndexOptions));
+          applySchemaCollation(schemaIndexKeysObject, options, this.schema.options);
 
           if (isIndexEqual(schemaIndexKeysObject, options, dbIndex)) {
             found = true;
@@ -1780,26 +1802,17 @@ function _ensureIndexes(model, options, callback) {
 
     const indexFields = utils.clone(index[0]);
     const indexOptions = utils.clone(index[1]);
-    let isTextIndex = false;
-    for (const key of Object.keys(indexFields)) {
-      if (indexFields[key] === 'text') {
-        isTextIndex = true;
-      }
-    }
+
     delete indexOptions._autoIndex;
     decorateDiscriminatorIndexOptions(model.schema, indexOptions);
     applyWriteConcern(model.schema, indexOptions);
+    applySchemaCollation(indexFields, indexOptions, model.schema.options);
 
     indexSingleStart(indexFields, options);
 
     if ('background' in options) {
       indexOptions.background = options.background;
     }
-    if (model.schema.options.hasOwnProperty('collation') &&
-        !indexOptions.hasOwnProperty('collation') &&
-        !isTextIndex) {
-      indexOptions.collation = model.schema.options.collation;
-    }
 
     model.collection.createIndex(indexFields, indexOptions, utils.tick(function(err, name) {
       indexSingleDone(err, indexFields, indexOptions, name);
@@ -2155,14 +2168,7 @@ Model.find = function find(conditions, projection, options, callback) {
 
   const mq = new this.Query({}, {}, this, this.$__collection);
   mq.select(projection);
-
   mq.setOptions(options);
-  if (this.schema.discriminatorMapping &&
-      this.schema.discriminatorMapping.isRoot &&
-      mq.selectedInclusively()) {
-    // Need to select discriminator key because original schema doesn't have it
-    mq.select(this.schema.options.discriminatorKey);
-  }
 
   callback = this.$handleCallbackError(callback);
 
@@ -2268,11 +2274,6 @@ Model.findOne = function findOne(conditions, projection, options, callback) {
   const mq = new this.Query({}, {}, this, this.$__collection);
   mq.select(projection);
   mq.setOptions(options);
-  if (this.schema.discriminatorMapping &&
-      this.schema.discriminatorMapping.isRoot &&
-      mq.selectedInclusively()) {
-    mq.select(this.schema.options.discriminatorKey);
-  }
 
   callback = this.$handleCallbackError(callback);
   return mq.findOne(conditions, callback);
@@ -4219,7 +4220,6 @@ Model.aggregate = function aggregate(pipeline, options, callback) {
 
   const aggregate = new Aggregate(pipeline || []);
   aggregate.model(this);
-
   if (options != null) {
     aggregate.option(options);
   }
@@ -4816,7 +4816,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;
@@ -4860,6 +4859,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

@@ -11,7 +11,8 @@ const MongooseError = require('./error/mongooseError');
 const ObjectParameterError = require('./error/objectParameter');
 const QueryCursor = require('./cursor/QueryCursor');
 const ReadPreference = require('./driver').get().ReadPreference;
-const applyGlobalMaxTimeMS = require('./helpers/query/applyGlobalMaxTimeMS');
+const ValidationError = require('./error/validation');
+const { applyGlobalMaxTimeMS, applyGlobalDiskUse } = require('./helpers/query/applyGlobalOption');
 const applyWriteConcern = require('./helpers/schema/applyWriteConcern');
 const cast = require('./cast');
 const castArrayFilters = require('./helpers/update/castArrayFilters');
@@ -2191,6 +2192,7 @@ function _castArrayFilters(query) {
  * @api private
  */
 Query.prototype._find = wrapThunk(function(callback) {
+
   this._castConditions();
 
   if (this.error() != null) {
@@ -2209,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
@@ -2227,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);
@@ -2410,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,
@@ -2452,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) => {
@@ -2566,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();
@@ -2593,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();
@@ -2813,6 +2831,7 @@ Query.prototype.__distinct = wrapThunk(function __distinct(callback) {
   }
 
   applyGlobalMaxTimeMS(this.options, this.model);
+  applyGlobalDiskUse(this.options, this.model);
 
   const options = this._optionsForExec();
 
@@ -3713,7 +3732,6 @@ Query.prototype.findOneAndReplace = function(filter, replacement, options, callb
  */
 Query.prototype._findOneAndReplace = wrapThunk(function(callback) {
   this._castConditions();
-
   if (this.error() != null) {
     callback(this.error());
     return null;
@@ -3724,9 +3742,6 @@ Query.prototype._findOneAndReplace = wrapThunk(function(callback) {
   convertNewToReturnDocument(options);
   let fields = null;
 
-  let castedDoc = new this.model(this._update, null, true);
-  this._update = castedDoc;
-
   this._applyPaths();
   if (this._fields != null) {
     options.projection = this._castFields(utils.clone(this._fields));
@@ -3737,7 +3752,34 @@ Query.prototype._findOneAndReplace = wrapThunk(function(callback) {
     }
   }
 
-  castedDoc.$validate(err => {
+  const runValidators = _getOption(this, 'runValidators', false);
+  if (runValidators === false) {
+    try {
+      this._update = this._castUpdate(this._update, true);
+    } catch (err) {
+      const validationError = new ValidationError();
+      validationError.errors[err.path] = err;
+      callback(validationError);
+      return null;
+    }
+
+    this._collection.collection.findOneAndReplace(filter, this._update || {}, options, _wrapThunkCallback(this, (err, res) => {
+      if (err) {
+        return callback(err);
+      }
+
+      const doc = res.value;
+
+      return this._completeOne(doc, res, callback);
+    }));
+
+    return;
+  }
+
+
+  let castedDoc = new this.model(this._update, null, true);
+  this._update = castedDoc;
+  castedDoc.validate(err => {
     if (err != null) {
       return callback(err);
     }
@@ -3860,7 +3902,11 @@ Query.prototype._findAndModify = function(type, callback) {
     }
 
     if (!isOverwriting) {
-      this._update = castDoc(this, opts.overwrite);
+      try {
+        this._update = this._castUpdate(this._update, opts.overwrite);
+      } catch (err) {
+        return callback(err);
+      }
       const _opts = Object.assign({}, opts, {
         setDefaultsOnInsert: this._mongooseOptions.setDefaultsOnInsert
       });
@@ -4055,10 +4101,10 @@ function _updateThunk(op, callback) {
     }
     this._update = new this.model(this._update, null, true);
   } else {
-    this._update = castDoc(this, options.overwrite);
-
-    if (this._update instanceof Error) {
-      callback(this._update);
+    try {
+      this._update = this._castUpdate(this._update, options.overwrite);
+    } catch (err) {
+      callback(err);
       return null;
     }
 
@@ -4897,19 +4943,6 @@ function castQuery(query) {
   }
 }
 
-/*!
- * castDoc
- * @api private
- */
-
-function castDoc(query, overwrite) {
-  try {
-    return query._castUpdate(query._update, overwrite);
-  } catch (err) {
-    return err;
-  }
-}
-
 /**
  * Specifies paths which should be populated with other documents.
  *

package/lib/queryhelpers.js

@@ -261,7 +261,17 @@ exports.applyPaths = function applyPaths(fields, schema) {
       delete fields[plusPath];
     }
 
-    if (typeof type.selected !== 'boolean') return;
+    if (typeof type.selected !== 'boolean') {
+      return;
+    }
+
+    // If set to 0, we're explicitly excluding the discriminator key. Can't do this for all fields,
+    // because we have tests that assert that using `-path` to exclude schema-level `select: true`
+    // fields counts as an exclusive projection. See gh-11546
+    if (exclude && type.selected && path === schema.options.discriminatorKey && fields[path] != null && !fields[path]) {
+      delete fields[path];
+      return;
+    }
 
     if (hasPlusPath) {
       // forced inclusion

package/lib/schema/SubdocumentPath.js

@@ -167,10 +167,11 @@ SubdocumentPath.prototype.cast = function(val, doc, init, priorVal, options) {
   const path = this.path;
   const selected = Object.keys(parentSelected).reduce((obj, key) => {
     if (key.startsWith(path + '.')) {
+      obj = obj || {};
       obj[key.substring(path.length + 1)] = parentSelected[key];
     }
     return obj;
-  }, {});
+  }, null);
   options = Object.assign({}, options, { priorDoc: priorVal });
   if (init) {
     subdoc = new Constructor(void 0, selected, doc);

package/lib/schema/documentarray.js

@@ -13,7 +13,6 @@ const SchemaType = require('../schematype');
 const discriminator = require('../helpers/model/discriminator');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
-const util = require('util');
 const utils = require('../utils');
 const getConstructor = require('../helpers/discriminator/getConstructor');
 
@@ -394,7 +393,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
 
   if (!Array.isArray(value)) {
     if (!init && !DocumentArrayPath.options.castNonArrays) {
-      throw new CastError('DocumentArray', util.inspect(value), this.path, null, this);
+      throw new CastError('DocumentArray', value, this.path, null, this);
     }
     // gh-2442 mark whole array as modified if we're initializing a doc from
     // the db and the path isn't an array in the document
@@ -486,8 +485,7 @@ DocumentArrayPath.prototype.cast = function(value, doc, init, prev, options) {
             // see gh-746
             rawArray[i] = subdoc;
           } catch (error) {
-            const valueInErrorMessage = util.inspect(rawArray[i]);
-            throw new CastError('embedded', valueInErrorMessage,
+            throw new CastError('embedded', rawArray[i],
               value[arrayPathSymbol], error, this);
           }
         }

package/lib/schema/objectid.js

@@ -282,11 +282,8 @@ function resetId(v) {
   if (this instanceof Document) {
     if (v === void 0) {
       const _v = new oid();
-      this.$__._id = _v;
       return _v;
     }
-
-    this.$__._id = v;
   }
 
   return v;

package/lib/schema/string.js

@@ -612,6 +612,10 @@ function handleSingle(val) {
   return this.castForQuery(val);
 }
 
+/*!
+ * ignore
+ */
+
 function handleArray(val) {
   const _this = this;
   if (!Array.isArray(val)) {
@@ -622,14 +626,32 @@ function handleArray(val) {
   });
 }
 
+/*!
+ * ignore
+ */
+
+function handleSingleNoSetters(val) {
+  if (val == null) {
+    return this._castNullish(val);
+  }
+
+  return this.cast(val, this);
+}
+
 const $conditionalHandlers = utils.options(SchemaType.prototype.$conditionalHandlers, {
   $all: handleArray,
   $gt: handleSingle,
   $gte: handleSingle,
   $lt: handleSingle,
   $lte: handleSingle,
-  $options: String,
-  $regex: handleSingle,
+  $options: handleSingleNoSetters,
+  $regex: function handle$regex(val) {
+    if (Object.prototype.toString.call(val) === '[object RegExp]') {
+      return val;
+    }
+
+    return handleSingleNoSetters.call(this, val);
+  },
   $not: handleSingle
 });