mongoose 6.2.6 → 6.2.9

package/lib/browserDocument.js

@@ -17,6 +17,7 @@ const isObject = require('./helpers/isObject');
  * Document constructor.
  *
  * @param {Object} obj the values to set
+ * @param {Object} schema
  * @param {Object} [fields] optional object containing the fields which were selected in the query returning this document and any populated paths data
  * @param {Boolean} [skipId] bool, should we auto create an ObjectId _id
  * @inherits NodeJS EventEmitter https://nodejs.org/api/events.html#events_class_events_eventemitter

package/lib/connection.js

@@ -788,10 +788,6 @@ Connection.prototype.openUri = function(uri, options, callback) {
     }
     _this.client = client;
 
-    for (const db of this.otherDbs) {
-      _setClient(db, client, {}, db.name);
-    }
-
     client.setMaxListeners(0);
     client.connect((error) => {
       if (error) {
@@ -800,6 +796,10 @@ Connection.prototype.openUri = function(uri, options, callback) {
 
       _setClient(_this, client, options, dbName);
 
+      for (const db of this.otherDbs) {
+        _setClient(db, client, {}, db.name);
+      }
+
       resolve(_this);
     });
   });

package/lib/cursor/AggregationCursor.js

@@ -26,7 +26,6 @@ const util = require('util');
  * Use [`Aggregate#cursor()`](/docs/api.html#aggregate_Aggregate-cursor) instead.
  *
  * @param {Aggregate} agg
- * @param {Object} options
  * @inherits Readable
  * @event `cursor`: Emitted when the cursor is created
  * @event `error`: Emitted when an error occurred

package/lib/cursor/QueryCursor.js

@@ -472,7 +472,8 @@ function _nextDoc(ctx, doc, pop, callback) {
     });
   }
 
-  ctx.query._completeOne(doc, null, (err, doc) => {
+  const { model, _fields, _userProvidedFields, options } = ctx.query;
+  helpers.createModelAndInit(model, doc, _fields, _userProvidedFields, options, pop, (err, doc) => {
     if (err != null) {
       return callback(err);
     }

package/lib/document.js

@@ -156,9 +156,9 @@ function Document(obj, fields, skipId, options) {
   if (obj) {
     // Skip set hooks
     if (this.$__original_set) {
-      this.$__original_set(obj, undefined, true);
+      this.$__original_set(obj, undefined, true, options);
     } else {
-      this.$set(obj, undefined, true);
+      this.$set(obj, undefined, true, options);
     }
 
     if (obj instanceof Document) {
@@ -801,7 +801,7 @@ function init(self, obj, doc, opts, prefix) {
       init(self, obj[i], doc[i], opts, path + '.');
     } else if (!schemaType) {
       doc[i] = obj[i];
-      if (!strict) {
+      if (!strict && !prefix) {
         self[i] = obj[i];
       }
     } else {
@@ -1836,6 +1836,7 @@ Document.prototype.$__path = function(path) {
  */
 
 Document.prototype.markModified = function(path, scope) {
+  // console.log('MarkModified', path, new Error().stack);
   this.$__.activePaths.modify(path);
   if (scope != null && !this.$isSubdocument) {
     this.$__.pathsToScopes = this.$__pathsToScopes || {};
@@ -2422,6 +2423,7 @@ Document.prototype.validate = function(pathsToValidate, options, callback) {
 
     this.$__validate(pathsToValidate, options, (error) => {
       this.$op = null;
+      this.$__.validating = null;
       cb(error);
     });
   }, this.constructor.events);
@@ -2472,7 +2474,6 @@ 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);
@@ -2484,28 +2485,53 @@ 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;
+
       for (const p of paths) {
-        if (p === null || p.startsWith(subdoc.$basePath + '.')) {
+        if (p === null || p.startsWith(fullPathToSubdoc + '.')) {
           paths.delete(p);
         }
       }
 
-      if (doc.$isModified(subdoc.$basePath, modifiedPaths) &&
-            !doc.isDirectModified(subdoc.$basePath) &&
-            !doc.$isDefault(subdoc.$basePath)) {
-        paths.add(subdoc.$basePath);
+      if (doc.$isModified(fullPathToSubdoc, modifiedPaths) &&
+            !doc.isDirectModified(fullPathToSubdoc) &&
+            !doc.$isDefault(fullPathToSubdoc)) {
+        paths.add(fullPathToSubdoc);
 
-        skipSchemaValidators[subdoc.$basePath] = true;
+        skipSchemaValidators[fullPathToSubdoc] = true;
       }
     }
   }
 
+  for (const path of paths) {
+    const _pathType = doc.$__schema.path(path);
+    if (!_pathType) {
+      continue;
+    }
+
+    // Optimization: if primitive path with no validators, or array of primitives
+    // with no validators, skip validating this path entirely.
+    if (!_pathType.caster && _pathType.validators.length === 0) {
+      paths.delete(path);
+    } else if (_pathType.$isMongooseArray &&
+      !_pathType.$isMongooseDocumentArray && // Skip document arrays...
+      !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
+      _pathType.validators.length === 0 && // and arrays with top-level validators
+      _pathType.$embeddedSchemaType.validators.length === 0) {
+      paths.delete(path);
+    }
+  }
+
   // from here on we're not removing items from paths
 
   // gh-661: if a whole array is modified, make sure to run validation on all
   // the children as well
   for (const path of paths) {
     const _pathType = doc.$__schema.path(path);
+
     if (!_pathType ||
         !_pathType.$isMongooseArray ||
         // To avoid potential performance issues, skip doc arrays whose children
@@ -2517,6 +2543,16 @@ function _getPathsToValidate(doc) {
       continue;
     }
 
+    // gh-11380: optimization. If the array isn't a document array and there's no validators
+    // on the array type, there's no need to run validation on the individual array elements.
+    if (_pathType &&
+        _pathType.$isMongooseArray &&
+        !_pathType.$isMongooseDocumentArray && // Skip document arrays...
+        !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
+        _pathType.$embeddedSchemaType.validators.length === 0) {
+      continue;
+    }
+
     const val = doc.$__getValue(path);
     _pushNestedArrayPaths(val, paths, path);
   }
@@ -2602,7 +2638,8 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
   const _this = this;
   const _complete = () => {
     let validationError = this.$__.validationError;
-    this.$__.validationError = undefined;
+    this.$__.validationError = null;
+    this.$__.validating = null;
 
     if (shouldValidateModifiedOnly && validationError != null) {
       // Remove any validation errors that aren't from modified paths
@@ -2648,6 +2685,7 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
   } else if (pathsToSkip) {
     paths = _handlePathsToSkip(paths, pathsToSkip);
   }
+
   if (paths.length === 0) {
     return immediate(function() {
       const error = _complete();

package/lib/helpers/document/handleSpreadDoc.js

@@ -2,14 +2,32 @@
 
 const utils = require('../../utils');
 
+const keysToSkip = new Set(['__index', '__parentArray', '_doc']);
+
 /**
  * Using spread operator on a Mongoose document gives you a
  * POJO that has a tendency to cause infinite recursion. So
  * we use this function on `set()` to prevent that.
  */
 
-module.exports = function handleSpreadDoc(v) {
+module.exports = function handleSpreadDoc(v, includeExtraKeys) {
   if (utils.isPOJO(v) && v.$__ != null && v._doc != null) {
+    if (includeExtraKeys) {
+      const extraKeys = {};
+      for (const key of Object.keys(v)) {
+        if (typeof key === 'symbol') {
+          continue;
+        }
+        if (key[0] === '$') {
+          continue;
+        }
+        if (keysToSkip.has(key)) {
+          continue;
+        }
+        extraKeys[key] = v[key];
+      }
+      return { ...v._doc, ...extraKeys };
+    }
     return v._doc;
   }
 

package/lib/helpers/query/castFilterPath.js

@@ -41,7 +41,6 @@ module.exports = function castFilterPath(query, schematype, val) {
         }
         continue;
       }
-      // cast(schematype.caster ? schematype.caster.schema : schema, nested, options, context);
     } else {
       val[$cond] = schematype.castForQueryWrapper({
         $conditional: $cond,

package/lib/index.js

@@ -24,7 +24,6 @@ const legacyPluralize = require('./helpers/pluralize');
 const utils = require('./utils');
 const pkg = require('../package.json');
 const cast = require('./cast');
-const clearValidating = require('./plugins/clearValidating');
 const removeSubdocs = require('./plugins/removeSubdocs');
 const saveSubdocs = require('./plugins/saveSubdocs');
 const trackTransaction = require('./plugins/trackTransaction');
@@ -107,8 +106,7 @@ function Mongoose(options) {
       [validateBeforeSave, { deduplicate: true }],
       [shardingPlugin, { deduplicate: true }],
       [removeSubdocs, { deduplicate: true }],
-      [trackTransaction, { deduplicate: true }],
-      [clearValidating, { deduplicate: true }]
+      [trackTransaction, { deduplicate: true }]
     ]
   });
 }

package/lib/model.js

@@ -245,8 +245,7 @@ function _applyCustomWhere(doc, where) {
  */
 
 Model.prototype.$__handleSave = function(options, callback) {
-  const _this = this;
-  let saveOptions = {};
+  const saveOptions = {};
 
   applyWriteConcern(this.$__schema, options);
   if (typeof options.writeConcern !== 'undefined') {
@@ -274,14 +273,10 @@ Model.prototype.$__handleSave = function(options, callback) {
   if ('checkKeys' in options) {
     saveOptions.checkKeys = options.checkKeys;
   }
-  const session = this.$session();
   if (!saveOptions.hasOwnProperty('session')) {
-    saveOptions.session = session;
+    saveOptions.session = this.$session();
   }
 
-  if (Object.keys(saveOptions).length === 0) {
-    saveOptions = null;
-  }
   if (this.$isNew) {
     // send entire doc
     const obj = this.toObject(saveToObjectOptions);
@@ -298,9 +293,9 @@ Model.prototype.$__handleSave = function(options, callback) {
     }
 
     this.$__version(true, obj);
-    this[modelCollectionSymbol].insertOne(obj, saveOptions, function(err, ret) {
+    this[modelCollectionSymbol].insertOne(obj, saveOptions, (err, ret) => {
       if (err) {
-        _setIsNew(_this, true);
+        _setIsNew(this, true);
 
         callback(err, null);
         return;
@@ -308,64 +303,67 @@ Model.prototype.$__handleSave = function(options, callback) {
 
       callback(null, ret);
     });
+
     this.$__reset();
     _setIsNew(this, false);
     // Make it possible to retry the insert
     this.$__.inserting = true;
-  } else {
-    // Make sure we don't treat it as a new object on error,
-    // since it already exists
-    this.$__.inserting = false;
-
-    const delta = this.$__delta();
-    if (delta) {
-      if (delta instanceof MongooseError) {
-        callback(delta);
-        return;
-      }
 
-      const where = this.$__where(delta[0]);
-      if (where instanceof MongooseError) {
-        callback(where);
-        return;
-      }
+    return;
+  }
 
-      _applyCustomWhere(this, where);
-      this[modelCollectionSymbol].updateOne(where, delta[1], saveOptions, (err, ret) => {
-        if (err) {
-          this.$__undoReset();
+  // Make sure we don't treat it as a new object on error,
+  // since it already exists
+  this.$__.inserting = false;
 
-          callback(err);
-          return;
-        }
-        ret.$where = where;
-        callback(null, ret);
-      });
-    } else {
-      const optionsWithCustomValues = Object.assign({}, options, saveOptions);
-      const where = this.$__where();
-      if (this.$__schema.options.optimisticConcurrency) {
-        const key = this.$__schema.options.versionKey;
-        const val = this.$__getValue(key);
-        if (val != null) {
-          where[key] = val;
-        }
-      }
-      this.constructor.exists(where, optionsWithCustomValues)
-        .then(documentExists => {
-          const matchedCount = !documentExists ? 0 : 1;
-          callback(null, { $where: where, matchedCount });
-        })
-        .catch(callback);
+  const delta = this.$__delta();
+  if (delta) {
+    if (delta instanceof MongooseError) {
+      callback(delta);
       return;
     }
 
-    // store the modified paths before the document is reset
-    this.$__.modifiedPaths = this.modifiedPaths();
-    this.$__reset();
+    const where = this.$__where(delta[0]);
+    if (where instanceof MongooseError) {
+      callback(where);
+      return;
+    }
 
-    _setIsNew(this, false);
+    _applyCustomWhere(this, where);
+    this[modelCollectionSymbol].updateOne(where, delta[1], saveOptions, (err, ret) => {
+      if (err) {
+        this.$__undoReset();
+
+        callback(err);
+        return;
+      }
+      ret.$where = where;
+      callback(null, ret);
+    });
+  } else {
+    const optionsWithCustomValues = Object.assign({}, options, saveOptions);
+    const where = this.$__where();
+    if (this.$__schema.options.optimisticConcurrency) {
+      const key = this.$__schema.options.versionKey;
+      const val = this.$__getValue(key);
+      if (val != null) {
+        where[key] = val;
+      }
+    }
+    this.constructor.exists(where, optionsWithCustomValues)
+      .then(documentExists => {
+        const matchedCount = !documentExists ? 0 : 1;
+        callback(null, { $where: where, matchedCount });
+      })
+      .catch(callback);
+    return;
   }
+
+  // store the modified paths before the document is reset
+  this.$__.modifiedPaths = this.modifiedPaths();
+  this.$__reset();
+
+  _setIsNew(this, false);
 };
 
 /*!
@@ -374,8 +372,8 @@ Model.prototype.$__handleSave = function(options, callback) {
 
 Model.prototype.$__save = function(options, callback) {
   this.$__handleSave(options, (error, result) => {
-    const hooks = this.$__schema.s.hooks;
     if (error) {
+      const hooks = this.$__schema.s.hooks;
       return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
         callback(error, this);
       });
@@ -423,6 +421,7 @@ Model.prototype.$__save = function(options, callback) {
         this.$__undoReset();
         error = new DocumentNotFoundError(result.$where,
           this.constructor.modelName, numAffected, result);
+        const hooks = this.$__schema.s.hooks;
         return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
           callback(error, this);
         });
@@ -516,9 +515,9 @@ Model.prototype.save = function(options, fn) {
     this.$__.saveOptions = options;
 
     this.$__save(options, error => {
-      this.$__.saving = undefined;
-      delete this.$__.saveOptions;
-      delete this.$__.$versionError;
+      this.$__.saving = null;
+      this.$__.saveOptions = null;
+      this.$__.$versionError = null;
       this.$op = null;
 
       if (error) {
@@ -1375,6 +1374,16 @@ Model.createCollection = function createCollection(options, callback) {
   this.schema.options.timeseries;
   if (timeseries != null) {
     options = Object.assign({ timeseries }, options);
+    if (options.expireAfterSeconds != null) {
+      // do nothing
+    } else if (options.expires != null) {
+      utils.expires(options);
+    } else if (this.schema.options.expireAfterSeconds != null) {
+      options.expireAfterSeconds = this.schema.options.expireAfterSeconds;
+    } else if (this.schema.options.expires != null) {
+      options.expires = this.schema.options.expires;
+      utils.expires(options);
+    }
   }
 
   callback = this.$handleCallbackError(callback);
@@ -1875,7 +1884,7 @@ Model.discriminators;
  * ####Note:
  * Only translate arguments of object type anything else is returned raw
  *
- * @param {Object} raw fields/conditions that may contain aliased keys
+ * @param {Object} fields fields/conditions that may contain aliased keys
  * @return {Object} the translated 'pure' fields/conditions
  */
 Model.translateAliases = function translateAliases(fields) {
@@ -2836,11 +2845,11 @@ Model.findByIdAndDelete = function(id, options, callback) {
  *
  * ####Examples:
  *
- *     A.findOneAndReplace(conditions, options, callback) // executes
- *     A.findOneAndReplace(conditions, options)  // return Query
- *     A.findOneAndReplace(conditions, callback) // executes
- *     A.findOneAndReplace(conditions) // returns Query
- *     A.findOneAndReplace()           // returns Query
+ *     A.findOneAndReplace(filter, replacement, options, callback) // executes
+ *     A.findOneAndReplace(filter, replacement, options)  // return Query
+ *     A.findOneAndReplace(filter, replacement, callback) // executes
+ *     A.findOneAndReplace(filter, replacement) // returns Query
+ *     A.findOneAndReplace()                    // returns Query
  *
  * @param {Object} filter Replace the first document that matches this filter
  * @param {Object} [replacement] Replace with this document
@@ -2861,8 +2870,10 @@ Model.findOneAndReplace = function(filter, replacement, options, callback) {
 
   if (arguments.length === 1 && typeof filter === 'function') {
     const msg = 'Model.findOneAndReplace(): First argument must not be a function.\n\n'
-        + '  ' + this.modelName + '.findOneAndReplace(conditions, callback)\n'
-        + '  ' + this.modelName + '.findOneAndReplace(conditions)\n'
+        + '  ' + this.modelName + '.findOneAndReplace(filter, replacement, options, callback)\n'
+        + '  ' + this.modelName + '.findOneAndReplace(filter, replacement, callback)\n'
+        + '  ' + this.modelName + '.findOneAndReplace(filter, replacement)\n'
+        + '  ' + this.modelName + '.findOneAndReplace(filter, callback)\n'
         + '  ' + this.modelName + '.findOneAndReplace()\n';
     throw new TypeError(msg);
   }

package/lib/options/SchemaDateOptions.js

@@ -48,6 +48,13 @@ Object.defineProperty(SchemaDateOptions.prototype, 'max', opts);
 /**
  * If set, Mongoose creates a TTL index on this path.
  *
+ * mongo TTL index `expireAfterSeconds` value will take 'expires' value expressed in seconds.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ "expireAt": { type: Date,  expires: 11 } });
+ *     // if 'expireAt' is set, then document expires at expireAt + 11 seconds
+ *
  * @api public
  * @property expires
  * @memberOf SchemaDateOptions
@@ -61,4 +68,4 @@ Object.defineProperty(SchemaDateOptions.prototype, 'expires', opts);
  * ignore
  */
 
-module.exports = SchemaDateOptions;
+module.exports = SchemaDateOptions;

package/lib/query.js

@@ -39,6 +39,31 @@ const utils = require('./utils');
 const validOps = require('./helpers/query/validOps');
 const wrapThunk = require('./helpers/query/wrapThunk');
 
+const queryOptionMethods = new Set([
+  'allowDiskUse',
+  'batchSize',
+  'collation',
+  'comment',
+  'explain',
+  'hint',
+  'j',
+  'lean',
+  'limit',
+  'maxScan',
+  'maxTimeMS',
+  'maxscan',
+  'projection',
+  'read',
+  'select',
+  'skip',
+  'slice',
+  'sort',
+  'tailable',
+  'w',
+  'writeConcern',
+  'wtimeout'
+]);
+
 /**
  * Query constructor used for building queries. You do not need
  * to instantiate a `Query` directly. Instead use Model functions like
@@ -1630,7 +1655,19 @@ Query.prototype.setOptions = function(options, overwrite) {
     }
   }
 
-  return Query.base.setOptions.call(this, options);
+  // set arbitrary options
+  for (const key of Object.keys(options)) {
+    if (queryOptionMethods.has(key)) {
+      const args = Array.isArray(options[key]) ?
+        options[key] :
+        [options[key]];
+      this[key].apply(this, args);
+    } else {
+      this.options[key] = options[key];
+    }
+  }
+
+  return this;
 };
 
 /**
@@ -3168,23 +3205,14 @@ Query.prototype._deleteMany = wrapThunk(function(callback) {
  */
 
 function completeOne(model, doc, res, options, fields, userProvidedFields, pop, callback) {
-  const opts = pop ?
-    { populated: pop }
-    : undefined;
-
   if (options.rawResult && doc == null) {
     _init(null);
     return null;
   }
 
-  const casted = helpers.createModel(model, doc, fields, userProvidedFields, options);
-  try {
-    casted.$init(doc, opts, _init);
-  } catch (error) {
-    _init(error);
-  }
+  helpers.createModelAndInit(model, doc, fields, userProvidedFields, options, pop, _init);
 
-  function _init(err) {
+  function _init(err, casted) {
     if (err) {
       return immediate(() => callback(err));
     }
@@ -5705,4 +5733,4 @@ Query.prototype.model;
  * Export
  */
 
-module.exports = Query;
+module.exports = Query;

package/lib/queryhelpers.js

@@ -123,6 +123,23 @@ exports.createModel = function createModel(model, doc, fields, userProvidedField
   return new model(undefined, fields, _opts);
 };
 
+/*!
+ * ignore
+ */
+
+exports.createModelAndInit = function createModelAndInit(model, doc, fields, userProvidedFields, options, populatedIds, callback) {
+  const initOpts = populatedIds ?
+    { populated: populatedIds } :
+    undefined;
+
+  const casted = exports.createModel(model, doc, fields, userProvidedFields, options);
+  try {
+    casted.$init(doc, initOpts, callback);
+  } catch (error) {
+    callback(error, casted);
+  }
+};
+
 /*!
  * ignore
  */

package/lib/schema/SubdocumentPath.js

@@ -26,7 +26,7 @@ module.exports = SubdocumentPath;
  * Single nested subdocument SchemaType constructor.
  *
  * @param {Schema} schema
- * @param {String} key
+ * @param {String} path
  * @param {Object} options
  * @inherits SchemaType
  * @api public
@@ -243,6 +243,9 @@ SubdocumentPath.prototype.doValidate = function(value, fn, scope, options) {
   }
 
   if (options && options.skipSchemaValidators) {
+    if (!value) {
+      return fn(null);
+    }
     return value.validate(fn);
   }
 

package/lib/schema/array.js

@@ -32,6 +32,7 @@ const emptyOpts = Object.freeze({});
  * @param {String} key
  * @param {SchemaType} cast
  * @param {Object} options
+ * @param {Object} schemaOptions
  * @inherits SchemaType
  * @api public
  */