@depup/mongoose 9.3.3-depup.0 → 9.8.0-depup.0

package/lib/document.js

@@ -562,27 +562,26 @@ function $applyDefaultsToNested(val, path, doc) {
 Document.prototype.$__buildDoc = function(obj, fields, skipId, exclude, hasIncludedChildren) {
   const doc = {};
 
-  const paths = Object.keys(this.$__schema.paths).
-    // Don't build up any paths that are underneath a map, we don't know
-    // what the keys will be
-    filter(p => !p.includes('$*'));
+  const paths = Object.keys(this.$__schema.paths);
   const plen = paths.length;
   let ii = 0;
 
   for (; ii < plen; ++ii) {
     const p = paths[ii];
 
-    if (p === '_id') {
-      if (skipId) {
-        continue;
-      }
-      if (obj && '_id' in obj) {
-        continue;
-      }
+    // Don't build up any paths that are underneath a map, we don't know
+    // what the keys will be
+    if (p.includes('$*')) {
+      continue;
     }
 
     const path = this.$__schema.paths[p].splitPath();
     const len = path.length;
+    // This loop only creates intermediate objects for nested paths: it never
+    // sets any leaf values, so single-segment paths are no-ops.
+    if (len === 1) {
+      continue;
+    }
     const last = len - 1;
     let curPath = '';
     let doc_ = doc;
@@ -757,6 +756,7 @@ function init(self, obj, doc, opts, prefix) {
   let i;
   const strict = self.$__.strictMode;
   const docSchema = self.$__schema;
+  const strictRead = docSchema.options.strictRead;
 
   for (let index = 0; index < len; ++index) {
     i = keys[index];
@@ -774,6 +774,14 @@ function init(self, obj, doc, opts, prefix) {
     }
 
     const value = obj[i];
+    if (!schemaType && strictRead && docSchema.pathType(path) === 'adhocOrUndefined') {
+      if (strictRead === 'throw') {
+        throw new StrictModeError(path, 'Field `' + path + '` is not in schema and strictRead is set to throw.');
+      } else if (strictRead === true) {
+        continue;
+      }
+    }
+
     if (!schemaType && utils.isPOJO(value)) {
       // assume nested object
       if (!doc[i]) {
@@ -786,6 +794,13 @@ function init(self, obj, doc, opts, prefix) {
       }
       init(self, value, doc[i], opts, path + '.');
     } else if (!schemaType) {
+      // Handle strictRead: filter unknown fields during document hydration from DB
+      if (strictRead === 'throw') {
+        throw new StrictModeError(path, 'Field `' + path + '` is not in schema and strictRead is set to throw.');
+      } else if (strictRead === true) {
+        // Skip this field - do not store in _doc
+        continue;
+      }
       doc[i] = value;
       if (!strict && !prefix) {
         self[i] = value;
@@ -1133,7 +1148,11 @@ Document.prototype.$set = function $set(path, val, type, options) {
       return this;
     }
 
-    options = Object.assign({}, options, { _skipMinimizeTopLevel: false });
+    // Only need to clone if we're overwriting `_skipMinimizeTopLevel`, recursive
+    // calls treat a missing `_skipMinimizeTopLevel` as `false`
+    if (_skipMinimizeTopLevel) {
+      options = Object.assign({}, options, { _skipMinimizeTopLevel: false });
+    }
 
     for (let i = 0; i < len; ++i) {
       key = keys[i];
@@ -1220,15 +1239,9 @@ Document.prototype.$set = function $set(path, val, type, options) {
   val = handleSpreadDoc(val, true);
 
   // if this doc is being constructed we should not trigger getters
-  const priorVal = (() => {
-    if (this.$__.priorDoc != null) {
-      return this.$__.priorDoc.$__getValue(path);
-    }
-    if (constructing) {
-      return void 0;
-    }
-    return this.$__getValue(path);
-  })();
+  const priorVal = this.$__.priorDoc != null ?
+    this.$__.priorDoc.$__getValue(path) :
+    (constructing ? void 0 : this.$__getValue(path));
 
   if (pathType === 'nested' && val) {
     if (typeof val === 'object' && val != null) {
@@ -1410,13 +1423,10 @@ Document.prototype.$set = function $set(path, val, type, options) {
   try {
     // If the user is trying to set a ref path to a document with
     // the correct model name, treat it as populated
-    const refMatches = (() => {
+    const refMatches = !(val instanceof Document) ? false : (() => {
       if (schema.options == null) {
         return false;
       }
-      if (!(val instanceof Document)) {
-        return false;
-      }
       const model = val.constructor;
 
       // Check ref
@@ -1954,7 +1964,9 @@ Document.prototype.get = function(path, type, options) {
 
   // Fast path if we know we're just accessing top-level path on the document:
   // just get the schema path, avoid `$__path()` because that does string manipulation
-  let schema = noDottedPath ? this.$__schema.paths[path] : this.$__path(path);
+  let schema = noDottedPath ?
+    Object.hasOwn(this.$__schema.paths, path) ? this.$__schema.paths[path] : undefined :
+    this.$__path(path);
   if (schema == null) {
     schema = this.$__schema.virtualpath(path);
 
@@ -1964,7 +1976,7 @@ Document.prototype.get = function(path, type, options) {
   }
 
   if (noDottedPath) {
-    let obj = this._doc[path];
+    let obj = Object.hasOwn(this._doc, path) ? this._doc[path] : undefined;
     if (adhoc) {
       obj = adhoc.cast(obj);
     }
@@ -1991,6 +2003,10 @@ Document.prototype.get = function(path, type, options) {
   }
 
   for (let i = 0, l = pieces.length; i < l; i++) {
+    if (specialProperties.has(pieces[i])) {
+      return undefined;
+    }
+
     if (obj?._doc) {
       obj = obj._doc;
     }
@@ -2012,7 +2028,7 @@ Document.prototype.get = function(path, type, options) {
 
   if (schema != null && options.getters !== false) {
     obj = schema.applyGetters(obj, this);
-  } else if (this.$__schema.nested[path] && options.virtuals) {
+  } else if (Object.hasOwn(this.$__schema.nested, path) && options.virtuals) {
     // Might need to apply virtuals if this is a nested path
     return applyVirtuals(this, clone(obj) || {}, { path: path });
   }
@@ -2870,7 +2886,8 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
 
     await this._execDocumentPostHooks('validate', options, error);
   } finally {
-    delete this.$__.validateModifiedOnly;
+    // Assign rather than `delete` to avoid putting `$__` in dictionary mode
+    this.$__.validateModifiedOnly = undefined;
     this.$op = null;
     this.$__.validating = null;
   }
@@ -2913,7 +2930,7 @@ function _completeValidate(doc) {
     }
   }
 
-  doc.$__.cachedRequired = {};
+  doc.$__.cachedRequired = null;
   doc.$emit('validate', doc);
   doc.constructor.emit('validate', doc);
 
@@ -2981,9 +2998,40 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
       // Skip $* paths - they represent map schemas, not actual document paths
       return;
     }
+
+    const _pathType = doc.$__schema.path(p);
+
+    // Optimization: if primitive path with no validators, or array of primitives
+    // with no validators, skip validating this path entirely.
+    // Note: paths with no _pathType (e.g. sub-paths under Mixed) must still be
+    // added, as they trigger validation of the parent Mixed path.
+    if (_pathType) {
+      if (!_pathType.schema &&
+        !_pathType.embeddedSchemaType &&
+        _pathType.validators.length === 0 &&
+        !_pathType.$parentSchemaDocArray &&
+        // gh-15957: skip this optimization for SchemaMap as maps can contain subdocuments
+        // that need validation even if the map itself has no validators
+        !_pathType.$isSchemaMap &&
+        !_pathType.$isSchemaUnion) {
+        return;
+      } 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) {
+        return;
+      }
+    }
+
     paths.add(p);
   }
 
+  const onlyPrimitiveValues = doc.$__hasOnlyPrimitiveValues();
+  if (onlyPrimitiveValues && paths.size === 0) {
+    return [[], doValidateOptions];
+  }
+
   if (!isNestedValidate) {
     // If we're validating a subdocument, all this logic will run anyway on the top-level document, so skip for subdocuments.
     // But only run for top-level subdocuments, because we're looking for subdocuments that are not modified at top-level but
@@ -3048,37 +3096,17 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
     }
   }
 
-  for (const path of paths) {
-    const _pathType = doc.$__schema.path(path);
-    if (!_pathType) {
-      continue;
-    }
-
-    if (_pathType.$isMongooseDocumentArray) {
-      for (const p of paths) {
-        if (p == null || p.startsWith(_pathType.path + '.')) {
-          paths.delete(p);
+  if (!onlyPrimitiveValues) {
+    for (const path of paths) {
+      const _pathType = doc.$__schema.path(path);
+      if (_pathType && _pathType.$isMongooseDocumentArray) {
+        for (const p of paths) {
+          if (p == null || p.startsWith(_pathType.path + '.')) {
+            paths.delete(p);
+          }
         }
       }
     }
-
-    // Optimization: if primitive path with no validators, or array of primitives
-    // with no validators, skip validating this path entirely.
-    if (!_pathType.schema &&
-      !_pathType.embeddedSchemaType &&
-      _pathType.validators.length === 0 &&
-      !_pathType.$parentSchemaDocArray &&
-      // gh-15957: skip this optimization for SchemaMap as maps can contain subdocuments
-      // that need validation even if the map itself has no validators
-      !_pathType.$isSchemaMap) {
-      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);
-    }
   }
 
 
@@ -3193,7 +3221,7 @@ function _pushNestedArrayPaths(val, paths, path) {
  * ignore
  */
 
-Document.prototype._execDocumentPreHooks = async function _execDocumentPreHooks(opName, options, argsForHooks) {
+Document.prototype._execDocumentPreHooks = function _execDocumentPreHooks(opName, options, argsForHooks) {
   const filter = buildMiddlewareFilter(options, 'pre');
   return this.$__middleware.execPre(opName, this, argsForHooks || [], { filter });
 };
@@ -3202,7 +3230,7 @@ Document.prototype._execDocumentPreHooks = async function _execDocumentPreHooks(
  * ignore
  */
 
-Document.prototype._execDocumentPostHooks = async function _execDocumentPostHooks(opName, options, error) {
+Document.prototype._execDocumentPostHooks = function _execDocumentPostHooks(opName, options, error) {
   const filter = buildMiddlewareFilter(options, 'post');
   return this.$__middleware.execPost(opName, this, [this], { error, filter });
 };
@@ -3253,6 +3281,9 @@ function _handlePathsToSkip(paths, pathsToSkip) {
 /**
  * Executes registered validation rules (skipping asynchronous validators) for this document.
  *
+ * **Deprecated.** Use [`validate()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()) instead.
+ * `validateSync()` does not run validation middleware and will be removed in Mongoose 10.
+ *
  * #### Note:
  *
  * This method is useful if you need synchronous validation.
@@ -3270,14 +3301,21 @@ function _handlePathsToSkip(paths, pathsToSkip) {
  * @param {object} [options] options for validation
  * @param {boolean} [options.validateModifiedOnly=false] If `true`, Mongoose will only validate modified paths, as opposed to modified paths and `required` paths.
  * @param {Array|string} [options.pathsToSkip] list of paths to skip. If set, Mongoose will validate every modified path that is not in this list.
- * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
- * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
- * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
  * @return {ValidationError|undefined} ValidationError if there are errors during validation, or undefined if there is no error.
+ * @deprecated Use `validate()` instead. `validateSync()` does not run middleware and will be removed in Mongoose 10.
  * @api public
  */
 
-Document.prototype.validateSync = function(pathsToValidate, options) {
+Document.prototype.validateSync = function() {
+  utils.warn('Mongoose: `Document.prototype.validateSync()` is deprecated and will be removed in Mongoose 10. Use `Document.prototype.validate()` instead.');
+  return this.$__validateSync.apply(this, arguments);
+};
+
+/*!
+ * ignore
+ */
+
+Document.prototype.$__validateSync = function(pathsToValidate, options) {
   const _this = this;
 
   if (arguments.length === 1 && typeof arguments[0] === 'object' && !Array.isArray(arguments[0])) {
@@ -3545,6 +3583,10 @@ function _checkImmutableSubpaths(subdoc, schematype, priorVal) {
  * @param {number} [options.wtimeout] sets a [timeout for the write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern).
  * @param {boolean} [options.checkKeys=true] the MongoDB driver prevents you from saving keys that start with '$' or contain '.' by default. Set this option to `false` to skip that check. See [restrictions on field names](https://www.mongodb.com/docs/manual/reference/limits/#Restrictions-on-Field-Names)
  * @param {boolean} [options.timestamps=true] if `false` and [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this `save()`.
+ * @param {Array} [options.pathsToSave] An array of paths that tell mongoose to only validate and save the paths in `pathsToSave`.
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
+ * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
  * @method save
  * @memberOf Document
  * @instance
@@ -3595,25 +3637,25 @@ Document.prototype.$isValid = function(path) {
 Document.prototype.$__reset = function reset() {
   let _this = this;
 
-  // Skip for subdocuments
-  const subdocs = !this.$isSubdocument ? this.$getAllSubdocs({ useCache: true }) : null;
+  const onlyPrimitiveValues = this.$__hasOnlyPrimitiveValues();
+
+  // Skip for subdocuments. Also skip if doc only has primitive values,
+  // because primitives can't be subdocs.
+  const subdocs = !this.$isSubdocument && !onlyPrimitiveValues ? this.$getAllSubdocs({ useCache: true }) : null;
   if (subdocs?.length > 0) {
     for (const subdoc of subdocs) {
       subdoc.$__reset();
     }
   }
 
-  // clear atomics
-  this.$__dirty().forEach(function(dirt) {
-    const type = dirt.value;
-
-    if (type && typeof type.clearAtomics === 'function') {
-      type.clearAtomics();
-    } else if (type && type[arrayAtomicsSymbol]) {
-      type[arrayAtomicsBackupSymbol] = type[arrayAtomicsSymbol];
-      type[arrayAtomicsSymbol] = {};
-    }
-  });
+  // Clear atomics on dirty paths. Walk the modified and default paths
+  // directly instead of calling $__dirty(), which builds intermediate
+  // arrays, a Map, and does parent-path deduplication we don't need here.
+  // Skip entirely if the doc only has primitive values, because only arrays
+  // and maps have atomics.
+  if (!onlyPrimitiveValues) {
+    this.$__resetAtomics();
+  }
 
   this.$__.backup = {};
   this.$__.backup.activePaths = {
@@ -3636,6 +3678,40 @@ Document.prototype.$__reset = function reset() {
   return this;
 };
 
+/*!
+ * Clear atomics on all dirty (modified + default) paths. This is a lighter
+ * alternative to calling `$__dirty()` when we only need to clear atomics
+ * and don't need the full {path, value, schema} objects or parent-path
+ * deduplication.
+ */
+
+Document.prototype.$__resetAtomics = function $__resetAtomics() {
+  const activePaths = this.$__.activePaths;
+  const modifyPaths = activePaths.getStatePaths('modify');
+  const defaultPaths = activePaths.getStatePaths('default');
+
+  _clearAtomicsOnPaths(this, modifyPaths);
+  _clearAtomicsOnPaths(this, defaultPaths);
+};
+
+function _clearAtomicsOnPaths(doc, paths) {
+  if (paths == null) {
+    return;
+  }
+  const keys = Object.keys(paths);
+  for (let i = 0; i < keys.length; ++i) {
+    const type = doc.$__getValue(keys[i]);
+    if (type != null) {
+      if (typeof type.clearAtomics === 'function') {
+        type.clearAtomics();
+      } else if (type[arrayAtomicsSymbol]) {
+        type[arrayAtomicsBackupSymbol] = type[arrayAtomicsSymbol];
+        type[arrayAtomicsSymbol] = {};
+      }
+    }
+  }
+}
+
 /*!
  * ignore
  */
@@ -3709,15 +3785,17 @@ Document.prototype.$__dirty = function() {
     }
 
     let top = null;
+    let foundParent = false;
 
     const array = parentPaths(item.path);
     for (let i = 0; i < array.length - 1; i++) {
       if (allPaths.has(array[i])) {
         top = allPaths.get(array[i]);
+        foundParent = true;
         break;
       }
     }
-    if (top == null) {
+    if (!foundParent) {
       minimal.push(item);
     } else if (top != null &&
         top[arrayAtomicsSymbol] != null &&
@@ -4660,6 +4738,9 @@ Document.prototype.equals = function(doc) {
  * @param {boolean} [options.getters=false] if true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. For example, you would need to set this option to `true` if you wanted to [add a `lowercase` getter to your `localField`](https://mongoosejs.com/docs/schematypes.html#schematype-options).
  * @param {boolean} [options.clone=false] When you do `BlogPost.find().populate('author')`, blog posts with the same author will share 1 copy of an `author` doc. Enable this option to make Mongoose clone populated docs before assigning them.
  * @param {object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://www.mongodb.com/docs/manual/tutorial/query-documents/), or a function that returns a filter object.
+ * @param {boolean} [options.skipInvalidIds=false] By default, Mongoose throws a cast error if `localField` and `foreignField` schemas don't line up. If you enable this option, Mongoose will instead filter out any `localField` properties that cannot be casted to `foreignField`'s schema type.
+ * @param {number} [options.perDocumentLimit=null] For legacy reasons, `limit` with `populate()` may give incorrect results when populating multiple parent documents because it executes a single query for all parents. If you set `perDocumentLimit`, Mongoose will execute a separate query per parent document to ensure correct per-document `limit`.
+ * @param {boolean} [options.strictPopulate=true] Set to false to allow populating paths that aren't defined in the given model's schema.
  * @param {Function} [options.transform=null] Function that Mongoose will call on every populated document that allows you to transform the populated document.
  * @param {object} [options.options=null] Additional options like `limit` and `lean`.
  * @param {boolean} [options.forceRepopulate=true] Set to `false` to prevent Mongoose from repopulating paths that are already populated
@@ -4995,34 +5076,53 @@ Document.prototype.$__fullPath = function(path) {
  *     });
  *
  *     // returns an empty object, no changes happened yet
- *     user.getChanges(); // { }
+ *     user.$getChanges(); // { }
  *
  *     user.country = undefined;
  *     user.age = 26;
  *
- *     user.getChanges(); // { $set: { age: 26 }, { $unset: { country: 1 } } }
+ *     user.$getChanges(); // { $set: { age: 26 }, { $unset: { country: 1 } } }
  *
  *     await user.save();
  *
- *     user.getChanges(); // { }
+ *     user.$getChanges(); // { }
  *
- * Modifying the object that `getChanges()` returns does not affect the document's
- * change tracking state. Even if you `delete user.getChanges().$set`, Mongoose
+ * Modifying the object that `$getChanges()` returns does not affect the document's
+ * change tracking state. Even if you `delete user.$getChanges().$set`, Mongoose
  * will still send a `$set` to the server.
  *
  * @return {object}
  * @api public
- * @method getChanges
+ * @method $getChanges
  * @memberOf Document
  * @instance
  */
 
-Document.prototype.getChanges = function() {
+Document.prototype.$getChanges = function() {
   const delta = this.$__delta();
   const changes = delta ? delta[1] : {};
   return changes;
 };
 
+/**
+ * **Deprecated.** Use `$getChanges()` instead.
+ *
+ * Returns the changes that happened to the document
+ * in the format that will be sent to MongoDB.
+ *
+ * @return {Object}
+ * @deprecated Use `$getChanges()` instead. `getChanges` does not use the `$` prefix convention and may conflict with user-defined schema methods/properties.
+ * @api public
+ * @method getChanges
+ * @memberOf Document
+ * @instance
+ */
+
+Document.prototype.getChanges = function() {
+  utils.warn('`getChanges()` is deprecated, use `$getChanges()` instead.');
+  return this.$getChanges();
+};
+
 /**
  * Produces a special query document of the modified properties used in updates.
  *
@@ -5052,20 +5152,26 @@ Document.prototype.$__delta = function $__delta(pathsToSave, pathsToSaveSet) {
   const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
   if (optimisticConcurrency) {
     if (Array.isArray(optimisticConcurrency)) {
-      const optCon = new Set(optimisticConcurrency);
-      const modPaths = this.modifiedPaths();
+      if (!this.$__schema.options._optimisticConcurrencySet) {
+        this.$__schema.options._optimisticConcurrencySet = new Set(optimisticConcurrency);
+      }
+      const optimisticConcurrencySet = this.$__schema.options._optimisticConcurrencySet;
+      const modPaths = this.directModifiedPaths();
       const hasRelevantModPaths = pathsToSave == null ?
-        modPaths.find(path => optCon.has(path)) :
-        modPaths.find(path => optCon.has(path) && isInPathsToSave(path, pathsToSaveSet, pathsToSave));
+        modPaths.find(path => _pathOverlapsSet(path, optimisticConcurrencySet)) :
+        modPaths.find(path => _pathOverlapsSet(path, optimisticConcurrencySet) && isInPathsToSave(path, pathsToSaveSet, pathsToSave));
       if (hasRelevantModPaths) {
         this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
       }
     } else if (Array.isArray(optimisticConcurrency?.exclude)) {
-      const excluded = new Set(optimisticConcurrency.exclude);
-      const modPaths = this.modifiedPaths();
+      if (!this.$__schema.options._optimisticConcurrencyExcludeSet) {
+        this.$__schema.options._optimisticConcurrencyExcludeSet = new Set(optimisticConcurrency.exclude);
+      }
+      const optimisticConcurrencyExcludeSet = this.$__schema.options._optimisticConcurrencyExcludeSet;
+      const modPaths = this.directModifiedPaths();
       const hasRelevantModPaths = pathsToSave == null ?
-        modPaths.find(path => !excluded.has(path)) :
-        modPaths.find(path => !excluded.has(path) && isInPathsToSave(path, pathsToSaveSet, pathsToSave));
+        modPaths.find(path => !_pathOrAncestorInSet(path, optimisticConcurrencyExcludeSet)) :
+        modPaths.find(path => !_pathOrAncestorInSet(path, optimisticConcurrencyExcludeSet) && isInPathsToSave(path, pathsToSaveSet, pathsToSave));
       if (hasRelevantModPaths) {
         this.$__.version = dirty.length ? VERSION_ALL : VERSION_WHERE;
       }
@@ -5198,6 +5304,12 @@ function checkDivergentArray(doc, path, array) {
     // If any array was selected using an $elemMatch projection, we deny the update.
     // NOTE: MongoDB only supports projected $elemMatch on top level array.
     const top = path.split('.')[0];
+    if (doc.$__.selected[top] && doc.$__.selected[top].$slice != null && utils.isMongooseArray(array)) {
+      const atomics = array[arrayAtomicsSymbol];
+      if (atomics.$set) {
+        return top;
+      }
+    }
     if (doc.$__.selected[top + '.$']) {
       return top;
     }
@@ -5573,24 +5685,47 @@ Document.prototype._applyVersionIncrement = function _applyVersionIncrement() {
 };
 
 /*!
- * Increment this document's version if necessary.
+ * Module exports.
  */
 
-Document.prototype._applyVersionIncrement = function _applyVersionIncrement() {
-  if (!this.$__.version) return;
-  const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
-
-  this.$__.version = undefined;
-  if (doIncrement) {
-    const key = this.$__schema.options.versionKey;
-    const version = this.$__getValue(key) || 0;
-    this.$__setValue(key, version + 1); // increment version if was successful
+/*!
+ * Check if `path` or any of its ancestor paths exist in `pathSet`.
+ * For example:
+ *   _pathOrAncestorInSet('profile.firstName', Set(['profile'])) === true
+ *   _pathOrAncestorInSet('profile', Set(['profile.firstName'])) === false
+ */
+function _pathOrAncestorInSet(path, pathSet) {
+  if (pathSet.has(path)) {
+    return true;
   }
-};
+  let idx = path.indexOf('.');
+  while (idx !== -1) {
+    if (pathSet.has(path.substring(0, idx))) {
+      return true;
+    }
+    idx = path.indexOf('.', idx + 1);
+  }
+  return false;
+}
 
 /*!
- * Module exports.
+ * Check if `path`, any of its ancestor paths, or any of its descendant paths
+ * exist in `pathSet`.
+ * For example:
+ *   _pathOverlapsSet('profile.firstName', Set(['profile'])) === true
+ *   _pathOverlapsSet('profile', Set(['profile.firstName'])) === true
  */
+function _pathOverlapsSet(path, pathSet) {
+  if (_pathOrAncestorInSet(path, pathSet)) {
+    return true;
+  }
+  for (const p of pathSet) {
+    if (p.length > path.length + 1 && p[path.length] === '.' && p.slice(0, path.length) === path) {
+      return true;
+    }
+  }
+  return false;
+}
 
 Document.VERSION_WHERE = VERSION_WHERE;
 Document.VERSION_INC = VERSION_INC;