mongoose 6.2.8 → 6.2.9

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) {
@@ -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);
@@ -2504,12 +2506,32 @@ function _getPathsToValidate(doc) {
     }
   }
 
+  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
@@ -2616,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

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) {

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;
 };
 
 /**
@@ -5696,4 +5733,4 @@ Query.prototype.model;
  * Export
  */
 
-module.exports = Query;
+module.exports = Query;

package/lib/schematype.js

@@ -22,6 +22,8 @@ const populateModelSymbol = require('./helpers/symbols').populateModelSymbol;
 const CastError = MongooseError.CastError;
 const ValidatorError = MongooseError.ValidatorError;
 
+const setOptionsForDefaults = { _skipMarkModified: true };
+
 /**
  * SchemaType constructor. Do **not** instantiate `SchemaType` directly.
  * Mongoose converts your schema paths into SchemaTypes automatically.
@@ -1124,7 +1126,7 @@ SchemaType.prototype.getDefault = function(scope, init) {
       ret = utils.clone(ret);
     }
 
-    const casted = this.applySetters(ret, scope, init);
+    const casted = this.applySetters(ret, scope, init, undefined, setOptionsForDefaults);
     if (casted && !Array.isArray(casted) && casted.$isSingleNested) {
       casted.$__parent = scope;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.2.8",
+  "version": "6.2.9",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -20,7 +20,7 @@
   "license": "MIT",
   "dependencies": {
     "bson": "^4.2.2",
-    "kareem": "2.3.4",
+    "kareem": "2.3.5",
     "mongodb": "4.3.1",
     "mpath": "0.8.4",
     "mquery": "4.0.2",
@@ -28,26 +28,26 @@
     "sift": "16.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.17.5",
+    "@babel/core": "7.17.8",
     "@babel/preset-env": "7.16.11",
-    "@typescript-eslint/eslint-plugin": "5.12.0",
-    "@typescript-eslint/parser": "5.12.0",
+    "@typescript-eslint/eslint-plugin": "5.16.0",
+    "@typescript-eslint/parser": "5.16.0",
     "acquit": "1.x",
     "acquit-ignore": "0.2.x",
     "acquit-require": "0.1.x",
     "axios": "0.26.1",
-    "babel-loader": "8.2.3",
+    "babel-loader": "8.2.4",
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
     "cheerio": "1.0.0-rc.10",
     "dox": "0.3.1",
-    "eslint": "8.9.0",
+    "eslint": "8.11.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "highlight.js": "9.18.3",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "marked": "2.1.3",
-    "mocha": "9.2.1",
+    "marked": "4.0.12",
+    "mocha": "9.2.2",
     "moment": "2.x",
     "mongodb-memory-server": "^8.3.0",
     "nyc": "^15.1.0",
@@ -55,7 +55,7 @@
     "q": "1.5.1",
     "serve-handler": "6.1.3",
     "tsd": "0.19.1",
-    "typescript": "4.5.5",
+    "typescript": "4.6.3",
     "uuid": "8.3.2",
     "webpack": "4.44.1"
   },

package/tools/repl.js

@@ -5,7 +5,7 @@ run().catch(error => {
   process.exit(-1);
 });
 
-async function run () {
+async function run() {
   const ReplSet = require('mongodb-memory-server').MongoMemoryReplSet;
 
   // Create new instance
@@ -15,20 +15,20 @@ async function run () {
     },
     instanceOpts: [
       // Set the expiry job in MongoDB to run every second
-      { 
+      {
         port: 27017,
-        args: ["--setParameter", "ttlMonitorSleepSecs=1"] },
+        args: ['--setParameter', 'ttlMonitorSleepSecs=1'] }
     ],
     dbName: 'mongoose_test',
     replSet: {
-      name: "rs0",
+      name: 'rs0',
       count: 2,
-      storageEngine: "wiredTiger",
-    },
+      storageEngine: 'wiredTiger'
+    }
   });
 
   await replSet.start();
   await replSet.waitUntilRunning();
-  console.log("MongoDB-ReplicaSet is now running.")
-  console.log(replSet.getUri("mongoose_test"));
+  console.log('MongoDB-ReplicaSet is now running.');
+  console.log(replSet.getUri('mongoose_test'));
 }

package/tools/sharded.js

@@ -6,7 +6,7 @@ run().catch(error => {
 });
 
 
-async function run () {
+async function run() {
   const Sharded = require('mongodb-topology-manager').Sharded;
 
   // Create new instance
@@ -17,13 +17,13 @@ async function run () {
 
   await topology.addShard([{
     options: {
-      bind_ip: 'localhost', port: 31000, dbpath: `/data/db/31000`, shardsvr: null
+      bind_ip: 'localhost', port: 31000, dbpath: '/data/db/31000', shardsvr: null
     }
   }], { replSet: 'rs1' });
 
   await topology.addConfigurationServers([{
     options: {
-      bind_ip: 'localhost', port: 35000, dbpath: `/data/db/35000`
+      bind_ip: 'localhost', port: 35000, dbpath: '/data/db/35000'
     }
   }], { replSet: 'rs0' });