mongoose 7.1.0 → 7.1.2

package/lib/connection.js

@@ -825,7 +825,6 @@ async function _createMongoClient(conn, uri, options) {
   options = processConnectionOptions(uri, options);
 
   if (options) {
-    options = clone(options);
 
     const autoIndex = options.config && options.config.autoIndex != null ?
       options.config.autoIndex :

package/lib/document.js

@@ -26,6 +26,7 @@ const flattenObjectWithDottedPaths = require('./helpers/path/flattenObjectWithDo
 const get = require('./helpers/get');
 const getEmbeddedDiscriminatorPath = require('./helpers/document/getEmbeddedDiscriminatorPath');
 const getKeysInSchemaOrder = require('./helpers/schema/getKeysInSchemaOrder');
+const getSubdocumentStrictValue = require('./helpers/schema/getSubdocumentStrictValue');
 const handleSpreadDoc = require('./helpers/document/handleSpreadDoc');
 const immediate = require('./helpers/immediate');
 const isDefiningProjection = require('./helpers/projection/isDefiningProjection');
@@ -52,6 +53,7 @@ const populateModelSymbol = require('./helpers/symbols').populateModelSymbol;
 const scopeSymbol = require('./helpers/symbols').scopeSymbol;
 const schemaMixedSymbol = require('./schema/symbols').schemaMixedSymbol;
 const parentPaths = require('./helpers/path/parentPaths');
+const getDeepestSubdocumentForPath = require('./helpers/document/getDeepestSubdocumentForPath');
 
 let DocumentArray;
 let MongooseArray;
@@ -1032,7 +1034,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
   let key;
   let prefix;
 
-  const strict = options && 'strict' in options
+  const userSpecifiedStrict = options && 'strict' in options;
+  let strict = userSpecifiedStrict
     ? options.strict
     : this.$__.strictMode;
 
@@ -1140,8 +1143,20 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   let pathType = this.$__schema.pathType(path);
+  let parts = null;
   if (pathType === 'adhocOrUndefined') {
-    pathType = getEmbeddedDiscriminatorPath(this, path, { typeOnly: true });
+    parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+    pathType = getEmbeddedDiscriminatorPath(this, parts, { typeOnly: true });
+  }
+  if (pathType === 'adhocOrUndefined' && !userSpecifiedStrict) {
+    // May be path underneath non-strict schema
+    if (parts == null) {
+      parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+    }
+    const subdocStrict = getSubdocumentStrictValue(this.$__schema, parts);
+    if (subdocStrict !== undefined) {
+      strict = subdocStrict;
+    }
   }
 
   // Assume this is a Mongoose document that was copied into a POJO using
@@ -1204,7 +1219,9 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   let schema;
-  const parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+  if (parts == null) {
+    parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+  }
 
   // Might need to change path for top-level alias
   if (typeof this.$__schema.aliases[parts[0]] === 'string') {
@@ -1233,6 +1250,11 @@ Document.prototype.$set = function $set(path, val, type, options) {
         // allow changes to sub paths of mixed types
         mixed = true;
         break;
+      } else if (schema.$isSchemaMap && schema.$__schemaType instanceof MixedSchema && i < parts.length - 1) {
+        // Map of mixed and not the last element in the path resolves to mixed
+        mixed = true;
+        schema = schema.$__schemaType;
+        break;
       }
     }
 
@@ -1377,15 +1399,19 @@ Document.prototype.$set = function $set(path, val, type, options) {
       didPopulate = true;
     }
 
-    if (this.$__schema.singleNestedPaths[path] == null && (!refMatches || !schema.$isSingleNested || !val.$__)) {
+    if (!refMatches || !schema.$isSingleNested || !val.$__) {
       // If this path is underneath a single nested schema, we'll call the setter
       // later in `$__set()` because we don't take `_doc` when we iterate through
       // a single nested doc. That's to make sure we get the correct context.
       // Otherwise we would double-call the setter, see gh-7196.
+      let setterContext = this;
+      if (this.$__schema.singleNestedPaths[path] != null && parts.length > 1) {
+        setterContext = getDeepestSubdocumentForPath(this, parts, this.schema);
+      }
       if (options != null && options.overwriteImmutable) {
-        val = schema.applySetters(val, this, false, priorVal, { overwriteImmutable: true });
+        val = schema.applySetters(val, setterContext, false, priorVal, { overwriteImmutable: true });
       } else {
-        val = schema.applySetters(val, this, false, priorVal);
+        val = schema.applySetters(val, setterContext, false, priorVal);
       }
     }
 
@@ -1560,13 +1586,6 @@ Document.prototype.$__shouldModify = function(pathToMark, path, options, constru
     return true;
   }
 
-  // Re: the note about gh-7196, `val` is the raw value without casting or
-  // setters if the full path is under a single nested subdoc because we don't
-  // want to double run setters. So don't set it as modified. See gh-7264.
-  if (this.$__schema.singleNestedPaths[path] != null) {
-    return false;
-  }
-
   if (val === void 0 && !this.$__isSelected(path)) {
     // when a path is not selected in a query, its initial
     // value will be undefined.
@@ -1674,17 +1693,26 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
         obj[parts[i]] = val;
       }
     } else {
-      if (utils.isPOJO(obj[parts[i]])) {
-        obj = obj[parts[i]];
-      } else if (obj[parts[i]] && obj[parts[i]] instanceof Embedded) {
-        obj = obj[parts[i]];
-      } else if (obj[parts[i]] && !Array.isArray(obj[parts[i]]) && obj[parts[i]].$isSingleNested) {
-        obj = obj[parts[i]];
-      } else if (obj[parts[i]] && Array.isArray(obj[parts[i]])) {
-        obj = obj[parts[i]];
+      const isMap = obj instanceof Map;
+      let value = isMap ? obj.get(parts[i]) : obj[parts[i]];
+      if (utils.isPOJO(value)) {
+        obj = value;
+      } else if (value && value instanceof Embedded) {
+        obj = value;
+      } else if (value && !Array.isArray(value) && value.$isSingleNested) {
+        obj = value._doc;
+      } else if (value && Array.isArray(value)) {
+        obj = value;
+      } else if (value == null) {
+        value = {};
+        if (isMap) {
+          obj.set(parts[i], value);
+        } else {
+          obj[parts[i]] = value;
+        }
+        obj = value;
       } else {
-        obj[parts[i]] = obj[parts[i]] || {};
-        obj = obj[parts[i]];
+        obj = value;
       }
     }
   }
@@ -1764,7 +1792,11 @@ Document.prototype.$inc = function $inc(path, val) {
 
   if (shouldSet) {
     this.$__.primitiveAtomics = this.$__.primitiveAtomics || {};
-    this.$__.primitiveAtomics[path] = { $inc: valToInc };
+    if (this.$__.primitiveAtomics[path] == null) {
+      this.$__.primitiveAtomics[path] = { $inc: valToInc };
+    } else {
+      this.$__.primitiveAtomics[path].$inc += valToInc;
+    }
     this.markModified(path);
     this.$__setValue(path, valToSet);
   }
@@ -2181,19 +2213,26 @@ Document.prototype[documentModifiedPaths] = Document.prototype.modifiedPaths;
 
 Document.prototype.isModified = function(paths, modifiedPaths) {
   if (paths) {
-    const directModifiedPaths = Object.keys(this.$__.activePaths.getStatePaths('modify'));
-    if (directModifiedPaths.length === 0) {
-      return false;
-    }
-
     if (!Array.isArray(paths)) {
       paths = paths.indexOf(' ') === -1 ? [paths] : paths.split(' ');
     }
+
+    const directModifiedPathsObj = this.$__.activePaths.states.modify;
+    if (directModifiedPathsObj == null) {
+      return false;
+    }
+    for (const path of paths) {
+      if (Object.prototype.hasOwnProperty.call(directModifiedPathsObj, path)) {
+        return true;
+      }
+    }
+
     const modified = modifiedPaths || this[documentModifiedPaths]();
     const isModifiedChild = paths.some(function(path) {
       return !!~modified.indexOf(path);
     });
 
+    const directModifiedPaths = Object.keys(directModifiedPathsObj);
     return isModifiedChild || paths.some(function(path) {
       return directModifiedPaths.some(function(mod) {
         return mod === path || path.startsWith(mod + '.');

package/lib/drivers/node-mongodb-native/collection.js

@@ -208,8 +208,14 @@ function iter(i) {
 
     if (debug) {
       if (typeof debug === 'function') {
+        let argsToAdd = null;
+        if (typeof args[args.length - 1] == 'function') {
+          argsToAdd = args.slice(0, args.length - 1);
+        } else {
+          argsToAdd = args;
+        }
         debug.apply(_this,
-          [_this.name, i].concat(args.slice(0, args.length - 1)));
+          [_this.name, i].concat(argsToAdd));
       } else if (debug instanceof stream.Writable) {
         this.$printToStream(_this.name, i, args, debug);
       } else {

package/lib/error/objectParameter.js

@@ -18,7 +18,7 @@ class ObjectParameterError extends MongooseError {
    */
   constructor(value, paramName, fnName) {
     super('Parameter "' + paramName + '" to ' + fnName +
-      '() must be an object, got ' + value.toString());
+      '() must be an object, got "' + value.toString() + '" (type ' + typeof value + ')');
   }
 }
 

package/lib/helpers/discriminator/mergeDiscriminatorSchema.js

@@ -55,7 +55,8 @@ module.exports = function mergeDiscriminatorSchema(to, from, path, seen) {
         // base schema has a given path as a single nested but discriminator schema
         // has the path as a document array, or vice versa (gh-9534)
         if ((from[key].$isSingleNested && to[key].$isMongooseDocumentArray) ||
-              (from[key].$isMongooseDocumentArray && to[key].$isSingleNested)) {
+              (from[key].$isMongooseDocumentArray && to[key].$isSingleNested) ||
+              (from[key].$isMongooseDocumentArrayElement && to[key].$isMongooseDocumentArrayElement)) {
           continue;
         } else if (from[key].instanceOfSchema) {
           if (to[key].instanceOfSchema) {

package/lib/helpers/document/getDeepestSubdocumentForPath.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Find the deepest subdocument along a given path to ensure setter functions run
+ * with the correct subdocument as `this`. If no subdocuments, returns the top-level
+ * document.
+ *
+ * @param {Document} doc
+ * @param {String[]} parts
+ * @param {Schema} schema
+ * @returns Document
+ */
+
+module.exports = function getDeepestSubdocumentForPath(doc, parts, schema) {
+  let curPath = parts[0];
+  let curSchema = schema;
+  let subdoc = doc;
+  for (let i = 0; i < parts.length - 1; ++i) {
+    const curSchemaType = curSchema.path(curPath);
+    if (curSchemaType && curSchemaType.schema) {
+      let newSubdoc = subdoc.get(curPath);
+      curSchema = curSchemaType.schema;
+      curPath = parts[i + 1];
+      if (Array.isArray(newSubdoc) && !isNaN(curPath)) {
+        newSubdoc = newSubdoc[curPath];
+        curPath = '';
+      }
+      if (newSubdoc == null) {
+        break;
+      }
+      subdoc = newSubdoc;
+    } else {
+      curPath += curPath.length ? '.' + parts[i + 1] : parts[i + 1];
+    }
+  }
+
+  return subdoc;
+};

package/lib/helpers/document/getEmbeddedDiscriminatorPath.js

@@ -6,8 +6,9 @@ const getSchemaDiscriminatorByValue = require('../discriminator/getSchemaDiscrim
 /**
  * Like `schema.path()`, except with a document, because impossible to
  * determine path type without knowing the embedded discriminator key.
+ *
  * @param {Document} doc
- * @param {String} path
+ * @param {String|String[]} path
  * @param {Object} [options]
  * @api private
  */
@@ -15,7 +16,9 @@ const getSchemaDiscriminatorByValue = require('../discriminator/getSchemaDiscrim
 module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
   options = options || {};
   const typeOnly = options.typeOnly;
-  const parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+  const parts = Array.isArray(path) ?
+    path :
+    (path.indexOf('.') === -1 ? [path] : path.split('.'));
   let schemaType = null;
   let type = 'adhocOrUndefined';
 

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -389,8 +389,7 @@ function _virtualPopulate(model, docs, options, _virtualRes) {
     let foreignField = virtual.options.foreignField;
 
     if (!localField || !foreignField) {
-      return new MongooseError('If you are populating a virtual, you must set the ' +
-        'localField and foreignField options');
+      return new MongooseError(`Cannot populate virtual \`${options.path}\` on model \`${model.modelName}\`, because options \`localField\` and / or \`foreignField\` are missing`);
     }
 
     if (typeof localField === 'function') {

package/lib/helpers/printJestWarning.js

@@ -2,16 +2,20 @@
 
 const utils = require('../utils');
 
-if (typeof jest !== 'undefined' && typeof window !== 'undefined') {
-  utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
-    'with Jest\'s default jsdom test environment. Please make sure you read ' +
-    'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
-    'https://mongoosejs.com/docs/jest.html');
-}
+if (typeof jest !== 'undefined' && !process.env.SUPPRESS_JEST_WARNINGS) {
+  if (typeof window !== 'undefined') {
+    utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
+      'with Jest\'s default jsdom test environment. Please make sure you read ' +
+      'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
+      'https://mongoosejs.com/docs/jest.html. Set the SUPPRESS_JEST_WARNINGS to true ' +
+      'to hide this warning.');
+  }
 
-if (typeof jest !== 'undefined' && setTimeout.clock != null && typeof setTimeout.clock.Date === 'function') {
-  utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
-    'with Jest\'s mock timers enabled. Please make sure you read ' +
-    'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
-    'https://mongoosejs.com/docs/jest.html');
+  if (setTimeout.clock != null && typeof setTimeout.clock.Date === 'function') {
+    utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
+      'with Jest\'s mock timers enabled. Please make sure you read ' +
+      'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
+      'https://mongoosejs.com/docs/jest.html. Set the SUPPRESS_JEST_WARNINGS to true ' +
+      'to hide this warning.');
+  }
 }

package/lib/helpers/processConnectionOptions.js

@@ -9,11 +9,12 @@ function processConnectionOptions(uri, options) {
     ? opts.readPreference
     : getUriReadPreference(uri);
 
+  const clonedOpts = clone(opts);
   const resolvedOpts = (readPreference && readPreference !== 'primary' && readPreference !== 'primaryPreferred')
-    ? resolveOptsConflicts(readPreference, opts)
-    : opts;
+    ? resolveOptsConflicts(readPreference, clonedOpts)
+    : clonedOpts;
 
-  return clone(resolvedOpts);
+  return resolvedOpts;
 }
 
 function resolveOptsConflicts(pref, opts) {

package/lib/helpers/schema/getSubdocumentStrictValue.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Find the `strict` mode setting for the deepest subdocument along a given path
+ * to ensure we have the correct default value for `strict`. When setting values
+ * underneath a subdocument, we should use the subdocument's `strict` setting by
+ * default, not the top-level document's.
+ *
+ * @param {Schema} schema
+ * @param {String[]} parts
+ * @returns {boolean | 'throw' | undefined}
+ */
+
+module.exports = function getSubdocumentStrictValue(schema, parts) {
+  if (parts.length === 1) {
+    return undefined;
+  }
+  let cur = parts[0];
+  let strict = undefined;
+  for (let i = 0; i < parts.length - 1; ++i) {
+    const curSchemaType = schema.path(cur);
+    if (curSchemaType && curSchemaType.schema) {
+      strict = curSchemaType.schema.options.strict;
+      schema = curSchemaType.schema;
+      cur = curSchemaType.$isMongooseDocumentArray && !isNaN(parts[i + 1]) ? '' : parts[i + 1];
+    } else {
+      cur += cur.length ? ('.' + parts[i + 1]) : parts[i + 1];
+    }
+  }
+
+  return strict;
+};

package/lib/helpers/timestamps/setupTimestamps.js

@@ -18,11 +18,9 @@ module.exports = function setupTimestamps(schema, timestamps) {
     const ts = s.schema.options.timestamps;
     return !!ts;
   }
-
   if (!timestamps && !childHasTimestamp) {
     return;
   }
-
   const createdAt = handleTimestampOption(timestamps, 'createdAt');
   const updatedAt = handleTimestampOption(timestamps, 'updatedAt');
   const currentTime = timestamps != null && timestamps.hasOwnProperty('currentTime') ?
@@ -57,15 +55,15 @@ module.exports = function setupTimestamps(schema, timestamps) {
 
   schema.methods.initializeTimestamps = function() {
     const ts = currentTime != null ?
-      currentTime() :
-      this.constructor.base.now();
+      currentTime() : this.constructor.base.now();
+
+
     if (createdAt && !this.get(createdAt)) {
       this.$set(createdAt, ts);
     }
     if (updatedAt && !this.get(updatedAt)) {
       this.$set(updatedAt, ts);
     }
-
     if (this.$isSubdocument) {
       return this;
     }
@@ -98,8 +96,14 @@ module.exports = function setupTimestamps(schema, timestamps) {
     if (replaceOps.has(this.op) && this.getUpdate() == null) {
       this.setUpdate({});
     }
-    applyTimestampsToUpdate(now, createdAt, updatedAt, this.getUpdate(),
-      this.options, this.schema);
+    applyTimestampsToUpdate(
+      now,
+      createdAt,
+      updatedAt,
+      this.getUpdate(),
+      this._mongooseOptions,
+      this.schema
+    );
     applyTimestampsToChildren(now, this.getUpdate(), this.model.schema);
     next();
   }

package/lib/query.js

@@ -1606,7 +1606,14 @@ Query.prototype.setOptions = function(options, overwrite) {
     this._mongooseOptions.sanitizeFilter = options.sanitizeFilter;
     delete options.sanitizeFilter;
   }
-
+  if ('overwrite' in options) {
+    this._mongooseOptions.overwrite = options.overwrite;
+    delete options.overwrite;
+  }
+  if ('timestamps' in options) {
+    this._mongooseOptions.timestamps = options.timestamps;
+    delete options.timestamps;
+  }
   if ('defaults' in options) {
     this._mongooseOptions.defaults = options.defaults;
     // deleting options.defaults will cause 7287 to fail
@@ -1864,7 +1871,7 @@ Query.prototype._updateForExec = function() {
   while (i--) {
     const op = ops[i];
 
-    if (this.options.overwrite) {
+    if (this._mongooseOptions.overwrite) {
       ret[op] = update[op];
       continue;
     }
@@ -1960,9 +1967,13 @@ Query.prototype._optionsForExec = function(model) {
     }
   }
 
-  const projection = this._fieldsForExec();
-  if (projection != null) {
-    options.projection = projection;
+  this._applyPaths();
+  if (this._fields != null) {
+    this._fields = this._castFields(this._fields);
+    const projection = this._fieldsForExec();
+    if (projection != null) {
+      options.projection = projection;
+    }
   }
 
   return options;
@@ -2211,10 +2222,6 @@ Query.prototype._find = async function _find() {
     throw this.error();
   }
 
-  this._applyPaths();
-  this._fields = this._castFields(this._fields);
-
-  const fields = this._fieldsForExec();
   const mongooseOptions = this._mongooseOptions;
   const _this = this;
   const userProvidedFields = _this._userProvidedFields || {};
@@ -2230,8 +2237,8 @@ Query.prototype._find = async function _find() {
   });
 
   const options = this._optionsForExec();
-  options.projection = this._fieldsForExec();
   const filter = this._conditions;
+  const fields = options.projection;
 
   const cursor = await this._collection.collection.find(filter, options);
   if (options.explain) {
@@ -2474,8 +2481,6 @@ Query.prototype._findOne = async function _findOne() {
     throw err;
   }
 
-  this._applyPaths();
-  this._fields = this._castFields(this._fields);
   applyGlobalMaxTimeMS(this.options, this.model);
   applyGlobalDiskUse(this.options, this.model);
 
@@ -3146,8 +3151,8 @@ function prepareDiscriminatorCriteria(query) {
  * @api public
  */
 
-Query.prototype.findOneAndUpdate = function(criteria, doc, options) {
-  if (typeof conditions === 'function' ||
+Query.prototype.findOneAndUpdate = function(filter, doc, options) {
+  if (typeof filter === 'function' ||
       typeof doc === 'function' ||
       typeof options === 'function' ||
       typeof arguments[3] === 'function') {
@@ -3163,13 +3168,17 @@ Query.prototype.findOneAndUpdate = function(criteria, doc, options) {
       options = undefined;
       break;
     case 1:
-      doc = criteria;
-      criteria = options = undefined;
+      doc = filter;
+      filter = options = undefined;
       break;
   }
 
-  if (mquery.canMerge(criteria)) {
-    this.merge(criteria);
+  if (mquery.canMerge(filter)) {
+    this.merge(filter);
+  } else if (filter != null) {
+    this.error(
+      new ObjectParameterError(filter, 'filter', 'findOneAndUpdate')
+    );
   }
 
   // apply doc
@@ -3371,7 +3380,7 @@ Query.prototype.findOneAndRemove = function(conditions, options) {
  *
  * @method findOneAndDelete
  * @memberOf Query
- * @param {Object} [conditions]
+ * @param {Object} [filter]
  * @param {Object} [options]
  * @param {Boolean} [options.rawResult] if true, returns the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html)
  * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
@@ -3381,8 +3390,8 @@ Query.prototype.findOneAndRemove = function(conditions, options) {
  * @api public
  */
 
-Query.prototype.findOneAndDelete = function(conditions, options) {
-  if (typeof conditions === 'function' ||
+Query.prototype.findOneAndDelete = function(filter, options) {
+  if (typeof filter === 'function' ||
       typeof options === 'function' ||
       typeof arguments[2] === 'function') {
     throw new MongooseError('Query.prototype.findOneAndDelete() no longer accepts a callback');
@@ -3392,8 +3401,8 @@ Query.prototype.findOneAndDelete = function(conditions, options) {
   this._validateOp();
   this._validate();
 
-  if (mquery.canMerge(conditions)) {
-    this.merge(conditions);
+  if (mquery.canMerge(filter)) {
+    this.merge(filter);
   }
 
   options && this.setOptions(options);
@@ -3505,6 +3514,10 @@ Query.prototype.findOneAndReplace = function(filter, replacement, options) {
 
   if (mquery.canMerge(filter)) {
     this.merge(filter);
+  } else if (filter != null) {
+    this.error(
+      new ObjectParameterError(filter, 'filter', 'findOneAndReplace')
+    );
   }
 
   if (replacement != null) {
@@ -3548,16 +3561,6 @@ Query.prototype._findOneAndReplace = async function _findOneAndReplace() {
   const filter = this._conditions;
   const options = this._optionsForExec();
   convertNewToReturnDocument(options);
-  let fields = null;
-
-  this._applyPaths();
-  if (this._fields != null) {
-    options.projection = this._castFields(clone(this._fields));
-    fields = options.projection;
-    if (fields instanceof Error) {
-      throw fields;
-    }
-  }
 
   const runValidators = _getOption(this, 'runValidators', false);
   if (runValidators === false) {
@@ -3786,7 +3789,7 @@ async function _updateThunk(op) {
   const options = this._optionsForExec(this.model);
 
   this._update = clone(this._update, options);
-  const isOverwriting = this.options.overwrite && !hasDollarKeys(this._update);
+  const isOverwriting = this._mongooseOptions.overwrite && !hasDollarKeys(this._update);
   if (isOverwriting) {
     if (op === 'updateOne' || op === 'updateMany') {
       throw new MongooseError('The MongoDB server disallows ' +
@@ -3795,7 +3798,7 @@ async function _updateThunk(op) {
     }
     this._update = new this.model(this._update, null, true);
   } else {
-    this._update = this._castUpdate(this._update, options.overwrite);
+    this._update = this._castUpdate(this._update, this._mongooseOptions.overwrite);
 
     if (this._update == null || Object.keys(this._update).length === 0) {
       return { acknowledged: false };
@@ -4883,6 +4886,9 @@ Query.prototype._castFields = function _castFields(fields) {
  */
 
 Query.prototype._applyPaths = function applyPaths() {
+  if (!this.model) {
+    return;
+  }
   this._fields = this._fields || {};
   helpers.applyPaths(this._fields, this.model.schema);
 
@@ -4941,9 +4947,6 @@ Query.prototype._applyPaths = function applyPaths() {
  */
 
 Query.prototype.cursor = function cursor(opts) {
-  this._applyPaths();
-  this._fields = this._castFields(this._fields);
-
   if (opts) {
     this.setOptions(opts);
   }