mongoose 9.10.4 → 9.11.1

package/lib/document.js

@@ -27,7 +27,6 @@ const isInPathsToSave = require('./helpers/document/isInPathsToSave');
 const compile = require('./helpers/document/compile').compile;
 const defineKey = require('./helpers/document/compile').defineKey;
 const firstKey = require('./helpers/firstKey');
-const flatten = require('./helpers/common').flatten;
 const getConstructorName = require('./helpers/getConstructorName');
 const getEmbeddedDiscriminatorPath = require('./helpers/document/getEmbeddedDiscriminatorPath');
 const getKeysInSchemaOrder = require('./helpers/schema/getKeysInSchemaOrder');
@@ -48,7 +47,6 @@ const utils = require('./utils');
 const isPromise = require('./helpers/isPromise');
 
 const deepEqual = utils.deepEqual;
-const isMongooseObject = utils.isMongooseObject;
 
 const applyDefaultsBeforeSettersOptions = Object.freeze({ skipParentChangeTracking: true });
 
@@ -65,6 +63,7 @@ const scopeSymbol = require('./helpers/symbols').scopeSymbol;
 const schemaMixedSymbol = require('./schema/symbols').schemaMixedSymbol;
 const getDeepestSubdocumentForPath = require('./helpers/document/getDeepestSubdocumentForPath');
 const sessionNewDocuments = require('./helpers/symbols').sessionNewDocuments;
+const toObjectRecursive = require('./helpers/document/toObjectRecursive');
 
 let DocumentArray;
 let Embedded;
@@ -1255,9 +1254,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
 
   if (pathType === 'nested' && val) {
     if (typeof val === 'object' && val != null) {
-      if (val.$__ != null) {
-        val = val.toObject(internalToObjectOptions);
-      }
+      val = toObjectRecursive(val, internalToObjectOptions);
       if (val == null) {
         this.invalidate(path, new MongooseError.CastError('Object', val, path));
         return this;
@@ -2819,24 +2816,9 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
     let paths;
     let doValidateOptionsByPath;
     if (validateAllPaths) {
-      paths = new Set(Object.keys(this.$__schema.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 schemaType = this.$__schema.path(path);
-        if (!schemaType?.$isMongooseArray) {
-          continue;
-        }
-        const val = this.$__getValue(path);
-        if (!val) {
-          continue;
-        }
-        _pushNestedArrayPaths(val, paths, path);
-      }
-      paths = [...paths];
-      doValidateOptionsByPath = {};
+      [paths, doValidateOptionsByPath] = _getAllPathsToValidate(this);
     } else {
-      const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip, options?._nestedValidate);
+      const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip);
       paths = shouldValidateModifiedOnly ?
         pathDetails[0].filter((path) => this.$isModified(path)) :
         pathDetails[0];
@@ -2918,6 +2900,9 @@ Document.prototype.validate = async function validate(pathsToValidate, options)
         validateAllPaths,
         _nestedValidate: true
       };
+      if (shouldValidateModifiedOnly) {
+        doValidateOptions.validateModifiedOnly = true;
+      }
 
       promises.push(
         schemaType.doValidate(val, scope, doValidateOptions).then(
@@ -3016,34 +3001,118 @@ function _completeValidate(doc) {
   return error;
 }
 
+/*!
+ * Build the list for `validateAllPaths`. The document array path validates
+ * every subdocument, but skips nullish elements. Add those elements separately
+ * so their element-level validators still run.
+ */
+
+function _getAllPathsToValidate(doc) {
+  const paths = Object.keys(doc.$__schema.paths).filter(path =>
+    path.charAt(path.length - 1) !== '*' ||
+    path.charAt(path.length - 2) !== '$' ||
+    path.charAt(path.length - 3) !== '.'
+  );
+  const doValidateOptionsByPath = {};
+
+  // gh-661: if a whole array is modified, make sure to run validation on all
+  // the children as well
+  for (let i = 0; i < paths.length; ++i) {
+    const path = paths[i];
+    const schemaType = doc.$__schema.path(path);
+    if (schemaType == null) {
+      continue;
+    }
+    const val = doc.$__getValue(path);
+    if (!val) {
+      continue;
+    }
+    if (schemaType.$isSchemaMap) {
+      for (const key of val.keys()) {
+        paths.push(path + '.' + key);
+      }
+    } else if (schemaType.$isMongooseDocumentArray) {
+      // The document array validates each of its subdocuments, so elements only
+      // need their own path listed if the element schematype has validators of
+      // its own, like `required` or `[{ type: childSchema, validate: fn }]`.
+      if (schemaType.embeddedSchemaType?.validators.length) {
+        for (let j = 0; j < val.length; ++j) {
+          const elementPath = path + '.' + j;
+          paths.push(elementPath);
+          doValidateOptionsByPath[elementPath] = { skipSubdocumentValidation: true, index: j };
+        }
+      }
+    } else if (schemaType.$isMongooseArray) {
+      _pushNestedArrayPaths(val, paths, path);
+    }
+  }
+
+  return [paths, doValidateOptionsByPath];
+}
+
+/*!
+ * ignore
+ */
+
 const STATES_TO_VALIDATE = Object.freeze(['init', 'default', 'modify']);
 const STAR_CHAR_CODE = '*'.charCodeAt(0);
 
 /*!
- * ignore
+ * Builds the list of paths to run validation on, plus per-path options for
+ * `doValidate()`.
+ *
+ * `activePaths` tells us which paths changed (`require`, `init`, `default`,
+ * `modify`), but that is neither a complete nor a minimal list of paths to
+ * validate, in four separate ways. Each phase below fixes exactly one:
+ *
+ *  1. Seed     Collect the changed paths, dropping ones that have nothing to
+ *              run and ones a subdocument already validates for us.
+ *  2. Resolve  Some entries are not schema paths at all: a modified nested
+ *              object is stored as one entry (`nest`), but the paths that
+ *              have validators are its children (`nest.name`).
+ *  3. Cover    Replace changed descendants with their actual subdocument or
+ *              document array, which owns validation below that path.
+ *  4. Augment  Primitive arrays, required document array elements, and maps
+ *              need concrete element or key paths listed individually.
+ *
+ * Validating a subdocument or document array validates everything underneath
+ * it, so `arr` makes `arr.0.name` redundant. Phase 3 uses the actual
+ * subdocuments and their modified paths to remove descendants seeded earlier.
+ * It runs for nested documents as well, so every document selects containers
+ * from its own schema without relying on `$parentSchemaDocArray`.
+ *
+ * If a document array element is modified, for example `arr.0.name`,
+ * array-level validators on `arr` still run. This behavior dates back to gh-6818.
+ *
+ * `pathsToValidate` / `pathsToSkip` are applied before augment, so that asking
+ * for `arr` still validates its elements. Duplicates are fine; both callers
+ * skip paths they have already validated.
  */
 
-function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate) {
-  const doValidateOptions = {};
+function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
   const schema = doc.$__schema;
   const schemaPaths = schema.paths;
+  const singleNestedPaths = schema.singleNestedPaths;
   const activeStates = doc.$__.activePaths.states;
-
-  // gh-16379: compute the modified-path set at most once and reuse it below, so
-  // checking many required paths doesn't rebuild it per-path (O(required x modified)).
-  let _modifiedPaths;
-  const getModifiedPaths = () => (_modifiedPaths ??= doc.modifiedPaths());
-
-  // only validate required fields when necessary
-  let paths = [];
+  const doValidateOptions = {};
+  // Subdocument and document array paths already in `paths`, which are the
+  // schema types that have a `schema` of their own. They run validation on
+  // their children, so nothing below one of these should be added.
+  const covered = {};
+  let paths = new Set();
+
+  // Phase 1: seed. Every path `activePaths` reports as changed, minus the ones
+  // with nothing to run and the ones a subdocument validates for us.
   const requireStates = activeStates.require;
   if (requireStates != null) {
     let modifiedPaths = null;
     for (const path in requireStates) {
+      const isOwnPath = Object.hasOwn(schemaPaths, path);
+      const type = isOwnPath ? schemaPaths[path] : schema.path(path);
+
       // Evaluate function-valued `required` for every required path, before any
       // filtering, so `invalidate()` calls and `cachedRequired` entries stay
       // consistent no matter which paths end up validated.
-      const type = Object.hasOwn(schemaPaths, path) ? schemaPaths[path] : schema.path(path);
       if (typeof type?.originalRequiredValue === 'function') {
         const cachedRequired = doc.$__.cachedRequired ?? (doc.$__.cachedRequired = {});
         try {
@@ -3054,24 +3123,26 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
       }
 
       if (!doc.$__isSelected(path)) {
-        if (modifiedPaths === null) {
-          modifiedPaths = doc.modifiedPaths();
-        }
+        modifiedPaths ??= doc.modifiedPaths();
         if (!doc.$isModified(path, null, modifiedPaths)) {
           continue;
         }
       }
+      // `.$*` paths represent map schemas, not actual document paths.
       if (path.charCodeAt(path.length - 1) === STAR_CHAR_CODE && path.endsWith('.$*')) {
-        // Skip $* paths - they represent map schemas, not actual document paths
         continue;
       }
       const cachedRequired = doc.$__.cachedRequired;
-      if (cachedRequired != null && path in cachedRequired) {
-        if (cachedRequired[path]) {
-          paths.push(path);
-        }
-      } else {
-        paths.push(path);
+      if (cachedRequired != null && path in cachedRequired && !cachedRequired[path]) {
+        continue;
+      }
+      if (!isOwnPath && type != null &&
+          Object.hasOwn(singleNestedPaths, path)) {
+        continue;
+      }
+      paths.add(path);
+      if (type != null && type.schema != null) {
+        covered[path] = true;
       }
     }
   }
@@ -3081,187 +3152,188 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
     if (statePaths == null) {
       continue;
     }
-    for (const p in statePaths) {
-      if (p.charCodeAt(p.length - 1) === STAR_CHAR_CODE && p.endsWith('.$*')) {
-        // Skip $* paths - they represent map schemas, not actual document paths
+    for (const path in statePaths) {
+      // `.$*` paths represent map schemas, not actual document paths.
+      if (path.charCodeAt(path.length - 1) === STAR_CHAR_CODE && path.endsWith('.$*')) {
         continue;
       }
-
-      const _pathType = Object.hasOwn(schemaPaths, p) ? schemaPaths[p] : 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) {
-          continue;
-        } 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) {
-          continue;
-        }
+      const isOwnPath = Object.hasOwn(schemaPaths, path);
+      const type = isOwnPath ? schemaPaths[path] : schema.path(path);
+      // Paths with no schema type must still be added so a parent schema path
+      // can handle them below.
+      if (type != null &&
+          (_hasNothingToValidate(type) ||
+            (!isOwnPath &&
+              Object.hasOwn(singleNestedPaths, path)))) {
+        continue;
+      }
+      // `schema.path()` resolves a path under Mixed to the Mixed parent. A
+      // modified Mixed child does not select the parent validator (gh-10141).
+      if (type?.[schemaMixedSymbol] != null && path !== type.path) {
+        continue;
+      }
+      paths.add(path);
+      if (type != null && type.schema != null) {
+        covered[path] = true;
       }
-
-      paths.push(p);
     }
   }
 
-  if (paths.length === 0 && doc.$__hasOnlyPrimitiveValues()) {
-    return [paths, doValidateOptions];
+  if (paths.size === 0 && doc.$__hasOnlyPrimitiveValues()) {
+    return [[], doValidateOptions];
+  }
+
+  // Phase 2: resolve. A modified nested object is a single entry in
+  // `activePaths`, but it is not a schema path and has no validators of its
+  // own, so replace it with its children. Children are added as we go, and a
+  // Set visits entries added during iteration, so this same loop also resolves
+  // nested objects several levels deep.
+  for (const path of paths) {
+    if (!schema.nested[path]) {
+      continue;
+    }
+    paths.delete(path);
+    const value = doc.$__getValue(path);
+    if (value == null || Array.isArray(value)) {
+      continue;
+    }
+    for (const key of Object.keys(value)) {
+      const child = path + '.' + key;
+      paths.add(child);
+      if (Object.hasOwn(schemaPaths, child) && schemaPaths[child].schema != null) {
+        covered[child] = true;
+      }
+    }
   }
 
-  paths = new Set(paths);
+  // Phase 3: cover. Validate modified single nested documents and document
+  // arrays as units, using actual subdocuments to remove redundant descendants.
+  const modifiedPaths = doc.modifiedPaths();
 
-  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
-    // have a modified path. If that is the case, we will run validation on the top-level subdocument, and via that run validation
-    // on any subdocuments down to the modified path.
-    const topLevelSubdocs = [];
-    for (const path of Object.keys(doc.$__schema.paths)) {
-      const schemaType = doc.$__schema.path(path);
-      if (schemaType.$isSingleNested) {
-        const subdoc = doc.$get(path);
-        if (subdoc) {
-          topLevelSubdocs.push(subdoc);
-        }
-      } else if (schemaType.$isMongooseDocumentArray) {
-        const arr = doc.$get(path);
-        if (arr?.length) {
-          for (const subdoc of arr) {
-            if (subdoc) {
-              topLevelSubdocs.push(subdoc);
-            }
-          }
-        }
+  const pathsWithSchemaTypes = Object.entries(schemaPaths);
+  // Map of document arrays may have subdocuments that are not in `schemaPaths` -
+  // If `team` is a map of document arrays, `team.engineering` is not a schema path
+  // but may be a modified document array.
+  for (const path of Object.keys(schemaPaths)) {
+    const schemaType = schemaPaths[path];
+    if (!schemaType.$isSchemaMap || !schemaType.$__schemaType.$isMongooseDocumentArray) {
+      continue;
+    }
+    const val = doc.$get(path);
+    if (val == null) {
+      continue;
+    }
+    for (const key of val.keys()) {
+      const mapValuePath = path + '.' + key;
+      if (modifiedPaths.includes(mapValuePath)) {
+        pathsWithSchemaTypes.push([mapValuePath, schemaType.$__schemaType]);
       }
     }
-    const modifiedPaths = getModifiedPaths();
+  }
 
-    // gh-6818: if a document array that has array-level validators has any
-    // modified element, validate the array itself so those validators run.
-    for (const modifiedPath of modifiedPaths) {
-      const modifiedPathType = doc.$__schema.path(modifiedPath);
-      if (modifiedPathType != null &&
-          modifiedPathType.$isMongooseDocumentArray &&
-          modifiedPathType.validators.length > 0) {
-        paths.add(modifiedPath);
+  for (const [path, schemaType] of pathsWithSchemaTypes) {
+    let subdocs;
+    if (schemaType.$isSingleNested) {
+      const subdoc = doc.$get(path);
+      if (subdoc == null) {
+        continue;
+      }
+      subdocs = [subdoc];
+    } else if (schemaType.$isMongooseDocumentArray) {
+      subdocs = doc.$get(path);
+      if (!subdocs?.length) {
+        continue;
+      }
+      // If a document array element is modified, for example `arr.0.name`,
+      // validate the whole array so array-level validators on `arr` still run.
+      // This behavior dates back to gh-6818.
+      if (modifiedPaths.includes(path) &&
+          (schemaType.validators.length > 0 || covered[path] === true)) {
+        if (covered[path] !== true && !Object.hasOwn(activeStates.modify, path)) {
+          doValidateOptions[path] = { skipSchemaValidators: true };
+        }
+        paths.add(path);
+        covered[path] = true;
       }
+    } else {
+      continue;
     }
 
-    for (const subdoc of topLevelSubdocs) {
-      if (subdoc.$basePath) {
-        const fullPathToSubdoc = subdoc.$__pathRelativeToParent();
+    // Validating the whole array validates every element, so element paths
+    // are redundant. They can be seeded before the array is, so drop them
+    // here rather than relying on the array being seen first.
+    const arrayCoversElements = schemaType.$isMongooseDocumentArray && covered[path] === true;
 
-        // Remove child paths for now, because we'll be validating the whole
-        // subdoc.
-        // The following is a faster take on looping through every path in `paths`
-        // and checking if the path starts with `fullPathToSubdoc` re: gh-13191
-        for (const modifiedPath of subdoc.modifiedPaths()) {
+    for (const subdoc of subdocs) {
+      if (subdoc == null || !subdoc.$basePath) {
+        continue;
+      }
+      const fullPathToSubdoc = schemaType.$isMongooseDocumentArray ?
+        path + '.' + subdoc.__index :
+        subdoc.$__pathRelativeToParent();
+      const subdocParent = subdoc.$parent();
+      if (subdocParent == null) {
+        throw new Error('Cannot validate subdocument that does not have a parent');
+      }
+      if (arrayCoversElements) {
+        paths.delete(fullPathToSubdoc);
+        for (const modifiedPath of subdoc.modifiedPaths({ includeChildren: true })) {
           paths.delete(fullPathToSubdoc + '.' + modifiedPath);
         }
-
-        const subdocParent = subdoc.$parent();
-        if (subdocParent == null) {
-          throw new Error('Cannot validate subdocument that does not have a parent');
+        if (path !== schemaType.path && Object.hasOwn(activeStates.modify, fullPathToSubdoc)) {
+          doValidateOptions[fullPathToSubdoc] = { skipSchemaValidators: false };
         }
-        if (doc.$isModified(fullPathToSubdoc, null, modifiedPaths) &&
-              // Avoid using isDirectModified() here because that does additional checks on whether the parent path
-              // is direct modified, which can cause performance issues re: gh-14897
-              !Object.hasOwn(subdocParent.$__.activePaths.getStatePaths('modify'), fullPathToSubdoc) &&
-              !subdocParent.$isDefault(fullPathToSubdoc)) {
-          paths.add(fullPathToSubdoc);
-
-          if (doc.$__.pathsToScopes == null) {
-            doc.$__.pathsToScopes = {};
-          }
-          doc.$__.pathsToScopes[fullPathToSubdoc] = subdoc.$isDocumentArrayElement ?
-            subdoc.__parentArray :
-            subdoc.$parent();
+      }
+      if (!doc.$isModified(fullPathToSubdoc, null, modifiedPaths) ||
+          // Avoid using isDirectModified() here because that does additional checks on whether the parent path
+          // is direct modified, which can cause performance issues re: gh-14897
+          Object.hasOwn(subdocParent.$__.activePaths.getStatePaths('modify'), fullPathToSubdoc) ||
+          subdocParent.$isDefault(fullPathToSubdoc)) {
+        continue;
+      }
 
-          doValidateOptions[fullPathToSubdoc] = { skipSchemaValidators: true };
-          if (subdoc.$isDocumentArrayElement && subdoc.__index != null) {
-            doValidateOptions[fullPathToSubdoc].index = subdoc.__index;
-          }
+      if (!arrayCoversElements) {
+        for (const modifiedPath of subdoc.modifiedPaths()) {
+          paths.delete(fullPathToSubdoc + '.' + modifiedPath);
         }
       }
-    }
-  }
 
-  if (!doc.$__hasOnlyPrimitiveValues()) {
-    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);
-          }
-        }
+      // The element's index and scope are still recorded even when the array
+      // covers it: `_addArrayPathsToValidate` may list the element below.
+      if (!arrayCoversElements && covered[path] !== true) {
+        paths.add(fullPathToSubdoc);
+      }
+      covered[fullPathToSubdoc] = true;
+      doc.$__.pathsToScopes ??= {};
+      doc.$__.pathsToScopes[fullPathToSubdoc] = subdoc.$isDocumentArrayElement ?
+        subdoc.__parentArray :
+        subdoc.$parent();
+      doValidateOptions[fullPathToSubdoc] ??= subdoc.$isDocumentArrayElement ?
+        {} :
+        { skipSchemaValidators: true };
+      if (subdoc.$isDocumentArrayElement && subdoc.__index != null) {
+        doValidateOptions[fullPathToSubdoc].index = subdoc.__index;
       }
     }
   }
 
-
   if (Array.isArray(pathsToValidate)) {
     paths = _handlePathsToValidate(paths, pathsToValidate);
   } else if (Array.isArray(pathsToSkip)) {
     paths = _handlePathsToSkip(paths, pathsToSkip);
   }
 
-  // from here on we're not removing items from paths
-
+  // Phase 4: augment. Arrays and maps only run their own validators, so their
+  // elements and keys need to be listed individually.
   // gh-661: if a whole array is modified, make sure to run validation on all
   // the children as well
-  _addArrayPathsToValidate(doc, paths);
-
-  const flattenOptions = { skipArrays: true };
-  for (const pathToCheck of paths) {
-    if (doc.$__schema.nested[pathToCheck]) {
-      let _v = doc.$__getValue(pathToCheck);
-      if (isMongooseObject(_v)) {
-        _v = _v.toObject({ transform: false });
-      }
-      const flat = flatten(_v, pathToCheck, flattenOptions, doc.$__schema);
-      // Single nested paths (paths embedded under single nested subdocs) will
-      // be validated on their own when we call `validate()` on the subdoc itself.
-      // Re: gh-8468
-      const singleNestedPaths = doc.$__schema.singleNestedPaths;
-      for (const path of Object.keys(flat)) {
-        if (!Object.hasOwn(singleNestedPaths, path) && !path.endsWith('.$*')) {
-          paths.add(path);
-        }
-      }
-    }
-  }
+  _addArrayPathsToValidate(doc, paths, doValidateOptions);
 
   for (const path of paths) {
-    const _pathType = doc.$__schema.path(path);
-
-    if (!_pathType) {
-      continue;
-    }
-
-    // If underneath a document array, may need to re-validate the parent
-    // array re: gh-6818. Do this _after_ adding subpaths, because
-    // we don't want to add every array subpath.
-    if (_pathType.$parentSchemaDocArray && typeof _pathType.$parentSchemaDocArray.path === 'string') {
-      paths.add(_pathType.$parentSchemaDocArray.path);
-    }
-
-    if (!_pathType.$isSchemaMap) {
+    const _pathType = schema.path(path);
+    if (!_pathType || !_pathType.$isSchemaMap) {
       continue;
     }
-
     const val = doc.$__getValue(path);
     if (val == null) {
       continue;
@@ -3271,11 +3343,35 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
     }
   }
 
-  paths = Array.from(paths);
-  return [paths, doValidateOptions];
+  // The callers index into the result, so hand them an array.
+  return [Array.from(paths), doValidateOptions];
 }
 
-function _addArrayPathsToValidate(doc, paths) {
+/*!
+ * Optimization: skip paths that cannot produce a validation error, either a
+ * primitive with no validators or an array of primitives with no validators on
+ * the array or its elements.
+ */
+
+function _hasNothingToValidate(type) {
+  if (!type.schema &&
+      !type.embeddedSchemaType &&
+      type.validators.length === 0 &&
+      // gh-15957: maps can contain subdocuments that need validation even if
+      // the map itself has no validators
+      !type.$isSchemaMap &&
+      !type.$isSchemaUnion) {
+    return true;
+  }
+  // gh-11380
+  return !!type.$isMongooseArray &&
+    !type.$isMongooseDocumentArray && // Skip document arrays...
+    !type.embeddedSchemaType.$isMongooseArray && // and arrays of arrays
+    type.validators.length === 0 &&
+    type.embeddedSchemaType.validators.length === 0;
+}
+
+function _addArrayPathsToValidate(doc, paths, doValidateOptions) {
   for (const path of paths) {
     const _pathType = doc.$__schema.path(path);
     if (!_pathType) {
@@ -3283,12 +3379,12 @@ function _addArrayPathsToValidate(doc, paths) {
     }
 
     if (!_pathType.$isMongooseArray ||
-        // To avoid potential performance issues, skip doc arrays whose children
-        // are not required. `getPositionalPathType()` may be slow, so avoid
-        // it unless we have a case of #6364
+        // To avoid potential performance issues, skip doc arrays whose elements
+        // have no validators of their own. `getPositionalPathType()` may be
+        // slow, so avoid it unless we have a case of #6364
         (!Array.isArray(_pathType) &&
           _pathType.$isMongooseDocumentArray &&
-          !_pathType?.schemaOptions?.required)) {
+          !_pathType.embeddedSchemaType?.validators.length)) {
       continue;
     }
 
@@ -3302,6 +3398,23 @@ function _addArrayPathsToValidate(doc, paths) {
     }
 
     const val = doc.$__getValue(path);
+    if (_pathType.$isMongooseDocumentArray) {
+      // We only get here because the document array itself is being validated,
+      // which validates every subdocument. Leave the subdocuments to it and run
+      // just the element-level validators here, so nothing validates twice.
+      const numElements = val?.length ?? 0;
+      for (let j = 0; j < numElements; ++j) {
+        const elementPath = path + '.' + j;
+        paths.add(elementPath);
+        doValidateOptions[elementPath] = {
+          ...doValidateOptions[path],
+          ...doValidateOptions[elementPath],
+          skipSubdocumentValidation: true,
+          index: j
+        };
+      }
+      continue;
+    }
     _pushNestedArrayPaths(val, paths, path);
   }
 }
@@ -3313,7 +3426,12 @@ function _pushNestedArrayPaths(val, paths, path) {
       if (Array.isArray(val[j])) {
         _pushNestedArrayPaths(val[j], paths, path + '.' + j);
       } else {
-        paths.add(path + '.' + j);
+        if (Array.isArray(paths)) {
+          paths.push(path + '.' + j);
+        } else {
+          // Set
+          paths.add(path + '.' + j);
+        }
       }
     }
   }
@@ -3359,9 +3477,21 @@ function _handlePathsToValidate(paths, pathsToValidate) {
     }
   }
 
+  // A Set: several paths can map onto the same `parentPaths` entry.
   const ret = new Set();
   for (const path of paths) {
-    if (_pathsToValidate.has(path)) {
+    let isUnderPathToValidate = false;
+    let index = path.length;
+    // Check if parent of this path is in `pathsToValidate`, e.g. if
+    // `profile` is in `pathsToValidate` then we should validate `profile.age`.
+    while ((index = path.lastIndexOf('.', index - 1)) !== -1) {
+      if (_pathsToValidate.has(path.slice(0, index))) {
+        isUnderPathToValidate = true;
+        break;
+      }
+    }
+
+    if (_pathsToValidate.has(path) || isUnderPathToValidate) {
       ret.add(path);
     } else if (parentPaths.has(path)) {
       ret.add(parentPaths.get(path));
@@ -3376,8 +3506,12 @@ function _handlePathsToValidate(paths, pathsToValidate) {
 
 function _handlePathsToSkip(paths, pathsToSkip) {
   pathsToSkip = new Set(pathsToSkip);
-  paths = Array.from(paths).filter(p => !pathsToSkip.has(p));
-  return new Set(paths);
+  for (const path of paths) {
+    if (pathsToSkip.has(path)) {
+      paths.delete(path);
+    }
+  }
+  return paths;
 }
 
 /**
@@ -3457,30 +3591,15 @@ Document.prototype.$__validateSync = function(pathsToValidate, options) {
 
   // only validate required fields when necessary
   let paths;
-  let skipSchemaValidators;
+  let doValidateOptionsByPath;
   if (validateAllPaths) {
-    paths = new Set(Object.keys(this.$__schema.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 schemaType = this.$__schema.path(path);
-      if (!schemaType?.$isMongooseArray) {
-        continue;
-      }
-      const val = this.$__getValue(path);
-      if (!val) {
-        continue;
-      }
-      _pushNestedArrayPaths(val, paths, path);
-    }
-    paths = [...paths];
-    skipSchemaValidators = {};
+    [paths, doValidateOptionsByPath] = _getAllPathsToValidate(this);
   } else {
     const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip);
     paths = shouldValidateModifiedOnly ?
       pathDetails[0].filter((path) => this.$isModified(path)) :
       pathDetails[0];
-    skipSchemaValidators = pathDetails[1];
+    doValidateOptionsByPath = pathDetails[1];
   }
 
   const validating = {};
@@ -3503,11 +3622,15 @@ Document.prototype.$__validateSync = function(pathsToValidate, options) {
     }
 
     const val = _this.$__getValue(path);
+    const pathOptions = doValidateOptionsByPath[path];
     const err = p.doValidateSync(val, _this, {
-      skipSchemaValidators: skipSchemaValidators[path],
+      ...(pathOptions != null && typeof pathOptions === 'object' ? pathOptions : null),
+      skipSchemaValidators: typeof pathOptions === 'object' ?
+        pathOptions.skipSchemaValidators : pathOptions,
       path: path,
       validateModifiedOnly: shouldValidateModifiedOnly,
-      validateAllPaths
+      validateAllPaths,
+      _nestedValidate: true
     });
     if (err) {
       const isSubdoc = p.$isSingleNested ||
@@ -4141,9 +4264,11 @@ Document.prototype.$toObject = function(options, json) {
     ?? false;
 
   let ret;
-  if (hasOnlyPrimitiveValues && !options.flattenObjectIds) {
+  if (hasOnlyPrimitiveValues && !options.flattenObjectIds && !options.flattenDecimals) {
     // Fast path: if we don't have any nested objects or arrays, we only need a
-    // shallow clone.
+    // shallow clone. Skipped for `flattenObjectIds` and `flattenDecimals`, because
+    // `$__hasOnlyPrimitiveValues()` counts ObjectIds and Decimal128s as primitives
+    // and only the full `clone()` path converts them.
     ret = this.$__toObjectShallow(schemaFieldsOnly);
   } else if (schemaFieldsOnly) {
     ret = {};