@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

package/.output/server/node_modules/mongoose/lib/helpers/populate/assignVals.js

@@ -129,11 +129,11 @@ module.exports = function assignVals(o) {
 
     if (isDoc && Array.isArray(valueToSet)) {
       for (const val of valueToSet) {
-        if (val != null && val.$__ != null) {
+        if (val?.$__ != null) {
           val.$__.parent = docs[i];
         }
       }
-    } else if (isDoc && valueToSet != null && valueToSet.$__ != null) {
+    } else if (isDoc && valueToSet?.$__ != null) {
       valueToSet.$__.parent = docs[i];
     }
 
@@ -184,7 +184,7 @@ module.exports = function assignVals(o) {
         // See gh-8342, gh-8455
         const curPath = parts.slice(0, j + 1).join('.');
         const schematype = originalSchema._getSchema(curPath);
-        if (valueToSet == null && schematype != null && schematype.$isMongooseArray) {
+        if (valueToSet == null && schematype?.$isMongooseArray) {
           break;
         }
         cur[parts[j]] = {};
@@ -200,7 +200,7 @@ module.exports = function assignVals(o) {
       o.allOptions.options[populateModelSymbol] = o.allOptions.model;
       docs[i].$populated(_path, o.unpopulatedValues[i], o.allOptions.options);
 
-      if (valueToSet != null && valueToSet.$__ != null) {
+      if (valueToSet?.$__ != null) {
         valueToSet.$__.wasPopulated = { value: o.unpopulatedValues[i] };
       }
 
@@ -256,11 +256,11 @@ function numDocs(v) {
  * background:
  * _ids are left in the query even when user excludes them so
  * that population mapping can occur.
- * @param {Any} val
- * @param {Object} assignmentOpts
- * @param {Object} populateOptions
+ * @param {any} val
+ * @param {object} assignmentOpts
+ * @param {object} populateOptions
  * @param {Function} [populateOptions.transform]
- * @param {Boolean} allIds
+ * @param {boolean} allIds
  * @api private
  */
 
@@ -327,7 +327,7 @@ function valueFilter(val, assignmentOpts, populateOptions, allIds) {
 /**
  * Remove _id from `subdoc` if user specified "lean" query option
  * @param {Document} subdoc
- * @param {Object} assignmentOpts
+ * @param {object} assignmentOpts
  * @api private
  */
 
@@ -344,7 +344,7 @@ function maybeRemoveId(subdoc, assignmentOpts) {
 /**
  * Determine if `obj` is something we can set a populated path to. Can be a
  * document, a lean document, or an array/map that contains docs.
- * @param {Any} obj
+ * @param {any} obj
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/populate/createPopulateQueryFilter.js

@@ -60,7 +60,7 @@ module.exports = function createPopulateQueryFilter(ids, _match, _foreignField,
  * to avoid cast errors (gh-7706)
  * @param {Array} ids
  * @param {SchemaType} foreignSchemaType
- * @param {Boolean} [skipInvalidIds]
+ * @param {boolean} [skipInvalidIds]
  * @api private
  */
 
@@ -73,7 +73,7 @@ function _filterInvalidIds(ids, foreignSchemaType, skipInvalidIds) {
     try {
       foreignSchemaType.cast(id);
       return true;
-    } catch (err) {
+    } catch {
       return false;
     }
   });
@@ -82,7 +82,7 @@ function _filterInvalidIds(ids, foreignSchemaType, skipInvalidIds) {
 /**
  * Format `mod.match` given that it may be an array that we need to $or if
  * the client has multiple docs with match functions
- * @param {Array|Any} match
+ * @param {Array|any} match
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/populate/getModelsMapForPopulate.js

@@ -17,15 +17,19 @@ const modelSymbol = require('../symbols').modelSymbol;
 const populateModelSymbol = require('../symbols').populateModelSymbol;
 const schemaMixedSymbol = require('../../schema/symbols').schemaMixedSymbol;
 const StrictPopulate = require('../../error/strictPopulate');
+const numericPathSegmentPattern = '\\.\\d+(?=\\.|$)';
+const hasNumericPathSegmentRE = new RegExp(numericPathSegmentPattern);
+const numericPathSegmentRE = new RegExp(numericPathSegmentPattern, 'g');
 
 module.exports = function getModelsMapForPopulate(model, docs, options) {
   let doc;
   const len = docs.length;
   const map = [];
-  const modelNameFromQuery = options.model && options.model.modelName || options.model;
+  const modelNameFromQuery = options.model?.modelName || options.model;
   let schema;
   let refPath;
   let modelNames;
+  let modelNamesSet;
   const available = {};
 
   const modelSchema = model.schema;
@@ -42,7 +46,8 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     return _virtualPopulate(model, docs, options, _virtualRes);
   }
 
-  let allSchemaTypes = getSchemaTypes(model, modelSchema, null, options.path);
+  const parts = modelSchema.paths[options.path]?.splitPath() ?? options.path.split('.');
+  let allSchemaTypes = getSchemaTypes(model, modelSchema, null, options.path, parts);
   allSchemaTypes = Array.isArray(allSchemaTypes) ? allSchemaTypes : [allSchemaTypes].filter(v => v != null);
 
   const isStrictPopulateDisabled = options.strictPopulate === false || options.options?.strictPopulate === false;
@@ -55,14 +60,14 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     let justOne = null;
 
     if (doc.$__ != null && doc.populated(options.path)) {
-      const forceRepopulate = options.forceRepopulate != null ? options.forceRepopulate : doc.constructor.base.options.forceRepopulate;
+      const forceRepopulate = options.forceRepopulate ?? doc.constructor.base.options.forceRepopulate;
       if (forceRepopulate === false) {
         continue;
       }
     }
 
-    const docSchema = doc != null && doc.$__ != null ? doc.$__schema : modelSchema;
-    schema = getSchemaTypes(model, docSchema, doc, options.path);
+    const docSchema = doc?.$__ != null ? doc.$__schema : modelSchema;
+    schema = getSchemaTypes(model, docSchema, doc, options.path, parts);
 
     // Special case: populating a path that's a DocumentArray unless
     // there's an explicit `ref` or `refPath` re: gh-8946
@@ -72,7 +77,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
         schema.options.refPath == null) {
       continue;
     }
-    const isUnderneathDocArray = schema && schema.$parentSchemaDocArray;
+    const isUnderneathDocArray = schema?.$parentSchemaDocArray;
     if (isUnderneathDocArray && get(options, 'options.sort') != null) {
       return new MongooseError('Cannot populate with `sort` on path ' + options.path +
         ' because it is a subproperty of a document array');
@@ -84,7 +89,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     let schemaOptions = null;
     let modelNamesInOrder = null;
 
-    if (schema != null && schema.instance === 'Embedded') {
+    if (schema?.instance === 'Embedded') {
       if (schema.options.ref) {
         const data = {
           localField: options.path + '._id',
@@ -123,8 +128,10 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
           continue;
         }
         modelNames = modelNames || [];
+        modelNamesSet = modelNamesSet || new Set();
         for (const modelName of _modelNames) {
-          if (modelNames.indexOf(modelName) === -1) {
+          if (modelNamesSet.has(modelName) === false) {
+            modelNamesSet.add(modelName);
             modelNames.push(modelName);
           }
         }
@@ -198,8 +205,11 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     data.modelNamesInOrder = modelNamesInOrder;
 
     if (isRefPath) {
+      const normalizedRefPathForDiscriminators = typeof normalizedRefPath === 'string' ?
+        normalizedRefPath.replace(numericPathSegmentRE, '') :
+        normalizedRefPath;
       const embeddedDiscriminatorModelNames = _findRefPathForDiscriminators(doc,
-        modelSchema, data, options, normalizedRefPath, ret);
+        modelSchema, data, options, normalizedRefPathForDiscriminators, ret);
 
       modelNames = embeddedDiscriminatorModelNames || modelNames;
     }
@@ -212,23 +222,23 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
   }
   return map;
 
-  function _getModelNames(doc, schema, modelNameFromQuery, model) {
+  function _getModelNames(doc, schemaType, modelNameFromQuery, model) {
     let modelNames;
     let isRefPath = false;
     let justOne = null;
 
-    const originalSchema = schema;
-    if (schema && schema.instance === 'Array') {
-      schema = schema.caster;
+    const originalSchema = schemaType;
+    if (schemaType?.instance === 'Array') {
+      schemaType = schemaType.embeddedSchemaType;
     }
-    if (schema && schema.$isSchemaMap) {
-      schema = schema.$__schemaType;
+    if (schemaType?.$isSchemaMap) {
+      schemaType = schemaType.$__schemaType;
     }
 
-    const ref = schema && schema.options && schema.options.ref;
-    refPath = schema && schema.options && schema.options.refPath;
-    if (schema != null &&
-        schema[schemaMixedSymbol] &&
+    const ref = schemaType?.options?.ref;
+    refPath = schemaType?.options?.refPath;
+    if (schemaType != null &&
+        schemaType[schemaMixedSymbol] &&
         !ref &&
         !refPath &&
         !modelNameFromQuery) {
@@ -239,19 +249,9 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
       modelNames = [modelNameFromQuery]; // query options
     } else if (refPath != null) {
       if (typeof refPath === 'function') {
-        const subdocPath = options.path.slice(0, options.path.length - schema.path.length - 1);
-        const vals = mpath.get(subdocPath, doc, lookupLocalFields);
-        const subdocsBeingPopulated = Array.isArray(vals) ?
-          utils.array.flatten(vals) :
-          (vals ? [vals] : []);
-
-        modelNames = new Set();
-        for (const subdoc of subdocsBeingPopulated) {
-          refPath = refPath.call(subdoc, subdoc, options.path);
-          modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection).
-            forEach(name => modelNames.add(name));
-        }
-        modelNames = Array.from(modelNames);
+        const res = _getModelNamesFromFunctionRefPath(refPath, doc, schemaType, options.path, modelSchema, options._queryProjection);
+        modelNames = res.modelNames;
+        refPath = res.refPath;
       } else {
         modelNames = modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection);
       }
@@ -265,7 +265,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
       let modelForCurrentDoc = model;
       const discriminatorKey = model.schema.options.discriminatorKey;
 
-      if (!schema && discriminatorKey && (discriminatorValue = utils.getValue(discriminatorKey, doc))) {
+      if (!schemaType && discriminatorKey && (discriminatorValue = utils.getValue(discriminatorKey, doc))) {
         // `modelNameForFind` is the discriminator value, so we might need
         // find the discriminated model name
         const discriminatorModel = getDiscriminatorByValue(model.discriminators, discriminatorValue) || model;
@@ -281,11 +281,11 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
 
         schemaForCurrentDoc = modelForCurrentDoc.schema._getSchema(options.path);
 
-        if (schemaForCurrentDoc && schemaForCurrentDoc.caster) {
-          schemaForCurrentDoc = schemaForCurrentDoc.caster;
+        if (schemaForCurrentDoc?.embeddedSchemaType) {
+          schemaForCurrentDoc = schemaForCurrentDoc.embeddedSchemaType;
         }
       } else {
-        schemaForCurrentDoc = schema;
+        schemaForCurrentDoc = schemaType;
       }
 
       if (originalSchema && originalSchema.path.endsWith('.$*')) {
@@ -319,22 +319,12 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
           ref = handleRefFunction(ref, doc);
           modelNames = [ref];
         }
-      } else if ((schemaForCurrentDoc = get(schema, 'options.refPath')) != null) {
+      } else if ((refPath = get(schemaForCurrentDoc, 'options.refPath')) != null) {
         isRefPath = true;
         if (typeof refPath === 'function') {
-          const subdocPath = options.path.slice(0, options.path.length - schemaForCurrentDoc.path.length - 1);
-          const vals = mpath.get(subdocPath, doc, lookupLocalFields);
-          const subdocsBeingPopulated = Array.isArray(vals) ?
-            utils.array.flatten(vals) :
-            (vals ? [vals] : []);
-
-          modelNames = new Set();
-          for (const subdoc of subdocsBeingPopulated) {
-            refPath = refPath.call(subdoc, subdoc, options.path);
-            modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection).
-              forEach(name => modelNames.add(name));
-          }
-          modelNames = Array.from(modelNames);
+          const res = _getModelNamesFromFunctionRefPath(refPath, doc, schemaForCurrentDoc, options.path, modelSchema, options._queryProjection);
+          modelNames = res.modelNames;
+          refPath = res.refPath;
         } else {
           modelNames = modelNamesFromRefPath(refPath, doc, options.path, modelSchema, options._queryProjection);
         }
@@ -358,6 +348,137 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
   }
 };
 
+/**
+ * Resolve model names for function-style `refPath` and return the first
+ * resolved refPath value so discriminator handling can inspect it later.
+ *
+ * @param {Function} refPath
+ * @param {Document|object} doc
+ * @param {SchemaType} schema
+ * @param {string} populatePath
+ * @param {Schema} modelSchema
+ * @param {object} queryProjection
+ * @returns {{modelNames: string[], refPath: string|null}}
+ * @private
+ */
+function _getModelNamesFromFunctionRefPath(refPath, doc, schemaType, populatePath, modelSchema, queryProjection) {
+  const modelNames = [];
+  let normalizedRefPath = null;
+  const schemaPath = schemaType?.path;
+
+  if (schemaPath != null &&
+      populatePath.length > schemaPath.length + 1 &&
+      populatePath.charAt(populatePath.length - schemaPath.length - 1) === '.' &&
+      populatePath.slice(populatePath.length - schemaPath.length) === schemaPath
+  ) {
+    const subdocPath = populatePath.slice(0, populatePath.length - schemaPath.length - 1);
+    const segments = subdocPath.indexOf('.') === -1 ? [subdocPath] : subdocPath.split('.');
+    let hasSubdoc = false;
+
+    walkSubdocs(doc, '', 0);
+    if (hasSubdoc) {
+      return { modelNames, refPath: normalizedRefPath };
+    }
+
+    function walkSubdocs(currentSubdoc, indexedPathPrefix, segmentIndex) {
+      if (currentSubdoc == null) {
+        return;
+      }
+
+      if (segmentIndex >= segments.length) {
+        hasSubdoc = true;
+        const indexedPath = indexedPathPrefix + '.' + schemaPath;
+        const subdocRefPath = refPath.call(currentSubdoc, currentSubdoc, indexedPath);
+        normalizedRefPath = normalizedRefPath || subdocRefPath;
+        modelNames.push(..._getModelNamesFromRefPath(subdocRefPath, doc, populatePath, indexedPath, modelSchema, queryProjection));
+        return;
+      }
+
+      const segment = segments[segmentIndex];
+      const source = currentSubdoc?._doc ?? currentSubdoc;
+
+      if (segment === '$*') {
+        if (source instanceof Map) {
+          for (const [key, value] of source.entries()) {
+            if (value != null) {
+              const valuePath = indexedPathPrefix.length === 0 ?
+                key :
+                indexedPathPrefix + '.' + key;
+              walkSubdocs(value, valuePath, segmentIndex + 1);
+            }
+          }
+          return;
+        }
+
+        if (source != null && typeof source === 'object') {
+          for (const key of Object.keys(source)) {
+            const value = source[key];
+            if (value != null) {
+              const valuePath = indexedPathPrefix.length === 0 ?
+                key :
+                indexedPathPrefix + '.' + key;
+              walkSubdocs(value, valuePath, segmentIndex + 1);
+            }
+          }
+        }
+        return;
+      }
+
+      const child = source[segment];
+      const childPath = indexedPathPrefix.length === 0 ?
+        segment :
+        indexedPathPrefix + '.' + segment;
+
+      if (Array.isArray(child)) {
+        for (let i = 0; i < child.length; ++i) {
+          if (child[i] != null) {
+            walkSubdocs(child[i], childPath + '.' + i, segmentIndex + 1);
+          }
+        }
+      } else if (child != null) {
+        walkSubdocs(child, childPath, segmentIndex + 1);
+      }
+    }
+  }
+
+  const topLevelRefPath = refPath.call(doc, doc, populatePath);
+  normalizedRefPath = normalizedRefPath || topLevelRefPath;
+  modelNames.push(...modelNamesFromRefPath(topLevelRefPath, doc, populatePath, modelSchema, queryProjection));
+
+  return { modelNames, refPath: normalizedRefPath };
+}
+
+/**
+ * Resolve model names from a refPath, preferring the indexed populated path
+ * for array subdocuments and falling back to the original populate path if
+ * normalization fails.
+ *
+ * @param {string|Function} refPath
+ * @param {Document|object} doc
+ * @param {string} populatePath
+ * @param {string} indexedPath
+ * @param {Schema} modelSchema
+ * @param {object} queryProjection
+ * @returns {string[]}
+ * @private
+ */
+function _getModelNamesFromRefPath(refPath, doc, populatePath, indexedPath, modelSchema, queryProjection) {
+  const populatedPath = typeof refPath === 'string' && hasNumericPathSegmentRE.test(refPath) ?
+    populatePath :
+    indexedPath;
+
+  try {
+    return modelNamesFromRefPath(refPath, doc, populatedPath, modelSchema, queryProjection);
+  } catch (error) {
+    if (populatedPath === indexedPath &&
+        typeof error?.message === 'string' &&
+        error.message.startsWith('Could not normalize ref path')) {
+      return modelNamesFromRefPath(refPath, doc, populatePath, modelSchema, queryProjection);
+    }
+    throw error;
+  }
+}
+
 /*!
  * ignore
  */
@@ -418,7 +539,15 @@ function _virtualPopulate(model, docs, options, _virtualRes) {
       justOne = options.justOne;
     }
 
-    modelNames = virtual._getModelNamesForPopulate(doc);
+    // Use the correct target doc/sub-doc for dynamic ref on nested schema. See gh-12363
+    if (_virtualRes.nestedSchemaPath && typeof virtual.options.ref === 'function') {
+      const subdocs = utils.getValue(_virtualRes.nestedSchemaPath, doc);
+      modelNames = Array.isArray(subdocs)
+        ? subdocs.flatMap(subdoc => virtual._getModelNamesForPopulate(subdoc))
+        : virtual._getModelNamesForPopulate(subdocs);
+    } else {
+      modelNames = virtual._getModelNamesForPopulate(doc);
+    }
     if (virtual.options.refPath) {
       justOne = !!virtual.options.justOne;
       data.isRefPath = true;
@@ -477,7 +606,7 @@ function _virtualPopulate(model, docs, options, _virtualRes) {
 function addModelNamesToMap(model, map, available, modelNames, options, data, ret, doc, schemaOptions, unpopulatedValue) {
   // `PopulateOptions#connection`: if the model is passed as a string, the
   // connection matters because different connections have different models.
-  const connection = options.connection != null ? options.connection : model.db;
+  const connection = options.connection ?? model.db;
 
   unpopulatedValue = unpopulatedValue === void 0 ? ret : unpopulatedValue;
   if (Array.isArray(unpopulatedValue)) {
@@ -515,7 +644,7 @@ function addModelNamesToMap(model, map, available, modelNames, options, data, re
 
     let ids = ret;
 
-    const modelNamesForRefPath = data.modelNamesInOrder ? data.modelNamesInOrder : modelNames;
+    const modelNamesForRefPath = data.modelNamesInOrder || modelNames;
     if (data.isRefPath && Array.isArray(ret) && ret.length === modelNamesForRefPath.length) {
       ids = matchIdsToRefPaths(ret, modelNamesForRefPath, modelName);
     }
@@ -614,10 +743,9 @@ function _getLocalFieldValues(doc, localField, model, options, virtual, schema)
   const localFieldPath = localFieldPathType === 'real' ?
     model.schema.path(localField) :
     localFieldPathType.schema;
-  const localFieldGetters = localFieldPath && localFieldPath.getters ?
-    localFieldPath.getters : [];
+  const localFieldGetters = localFieldPath?.getters || [];
 
-  localField = localFieldPath != null && localFieldPath.instance === 'Embedded' ? localField + '._id' : localField;
+  localField = localFieldPath?.instance === 'Embedded' ? localField + '._id' : localField;
 
   const _populateOptions = get(options, 'options', {});
 
@@ -642,24 +770,24 @@ function _getLocalFieldValues(doc, localField, model, options, virtual, schema)
 /**
  * Retrieve the _id of `val` if a Document or Array of Documents.
  *
- * @param {Array|Document|Any} val
+ * @param {Array|Document|any} val
  * @param {Schema} schema
- * @return {Array|Document|Any}
+ * @return {Array|Document|any}
  * @api private
  */
 
 function convertTo_id(val, schema) {
-  if (val != null && val.$__ != null) {
+  if (val?.$__ != null) {
     return val._doc._id;
   }
-  if (val != null && val._id != null && (schema == null || !schema.$isSchemaMap)) {
+  if (val?._id != null && !schema?.$isSchemaMap) {
     return val._id;
   }
 
   if (Array.isArray(val)) {
-    const rawVal = val.__array != null ? val.__array : val;
+    const rawVal = val.__array ?? val;
     for (let i = 0; i < rawVal.length; ++i) {
-      if (rawVal[i] != null && rawVal[i].$__ != null) {
+      if (rawVal[i]?.$__ != null) {
         rawVal[i] = rawVal[i]._doc._id;
       }
     }
@@ -675,7 +803,7 @@ function convertTo_id(val, schema) {
   if (getConstructorName(val) === 'Object' &&
       // The intent here is we should only flatten the object if we expect
       // to get a Map in the end. Avoid doing this for mixed types.
-      (schema == null || schema[schemaMixedSymbol] == null)) {
+      schema?.[schemaMixedSymbol] == null) {
     const ret = [];
     for (const key of Object.keys(val)) {
       ret.push(val[key]);
@@ -711,17 +839,17 @@ function _findRefPathForDiscriminators(doc, modelSchema, data, options, normaliz
     cur = cur + (cur.length === 0 ? '' : '.') + piece;
     const schematype = modelSchema.path(cur);
     if (schematype != null &&
-        schematype.$isMongooseArray &&
-        schematype.caster.discriminators != null &&
-        Object.keys(schematype.caster.discriminators).length !== 0) {
+        schematype.$isMongooseDocumentArray &&
+        schematype.Constructor.discriminators != null &&
+        utils.hasOwnKeys(schematype.Constructor.discriminators)) {
       const subdocs = utils.getValue(cur, doc);
       const remnant = options.path.substring(cur.length + 1);
-      const discriminatorKey = schematype.caster.schema.options.discriminatorKey;
+      const discriminatorKey = schematype.Constructor.schema.options.discriminatorKey;
       modelNames = [];
       for (const subdoc of subdocs) {
         const discriminatorName = utils.getValue(discriminatorKey, subdoc);
-        const discriminator = schematype.caster.discriminators[discriminatorName];
-        const discriminatorSchema = discriminator && discriminator.schema;
+        const discriminator = schematype.Constructor.discriminators[discriminatorName];
+        const discriminatorSchema = discriminator?.schema;
         if (discriminatorSchema == null) {
           continue;
         }

package/.output/server/node_modules/mongoose/lib/helpers/populate/getSchemaTypes.js

@@ -20,24 +20,24 @@ const populateModelSymbol = require('../symbols').populateModelSymbol;
  *
  * @param {Model} model
  * @param {Schema} schema
- * @param {Object} doc POJO
+ * @param {object} doc POJO
  * @param {string} path
+ * @param {string[]} [parts] pass in pre-split `path` to avoid extra splitting
  * @api private
  */
 
-module.exports = function getSchemaTypes(model, schema, doc, path) {
+module.exports = function getSchemaTypes(model, schema, doc, path, parts) {
   const pathschema = schema.path(path);
   const topLevelDoc = doc;
   if (pathschema) {
     return pathschema;
   }
 
-  const discriminatorKey = schema.discriminatorMapping &&
-    schema.discriminatorMapping.key;
+  const discriminatorKey = schema.discriminatorMapping?.key;
   if (discriminatorKey && model != null) {
-    if (doc != null && doc[discriminatorKey] != null) {
+    if (doc?.[discriminatorKey] != null) {
       const discriminator = getDiscriminatorByValue(model.discriminators, doc[discriminatorKey]);
-      schema = discriminator ? discriminator.schema : schema;
+      schema = discriminator?.schema || schema;
     } else if (model.discriminators != null) {
       return Object.keys(model.discriminators).reduce((arr, name) => {
         const disc = model.discriminators[name];
@@ -58,14 +58,14 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
         continue;
       }
 
-      if (foundschema.caster) {
+      if (foundschema.embeddedSchemaType || foundschema.schema) {
         // array of Mixed?
-        if (foundschema.caster instanceof Mixed) {
-          return foundschema.caster;
+        if (foundschema.embeddedSchemaType instanceof Mixed) {
+          return foundschema.embeddedSchemaType;
         }
 
         let schemas = null;
-        if (foundschema.schema != null && foundschema.schema.discriminators != null) {
+        if (foundschema.schema?.discriminators != null) {
           const discriminators = foundschema.schema.discriminators;
           const discriminatorKeyPath = trypath + '.' +
             foundschema.schema.options.discriminatorKey;
@@ -142,11 +142,11 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
           }
         } else if (p !== parts.length &&
             foundschema.$isMongooseArray &&
-            foundschema.casterConstructor.$isMongooseArray) {
+            foundschema.embeddedSchemaType.$isMongooseArray) {
           // Nested arrays. Drill down to the bottom of the nested array.
           let type = foundschema;
           while (type.$isMongooseArray && !type.$isMongooseDocumentArray) {
-            type = type.casterConstructor;
+            type = type.embeddedSchemaType;
           }
 
           const ret = search(
@@ -178,7 +178,7 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
       }
 
       const fullPath = nestedPath.concat([trypath]).join('.');
-      if (topLevelDoc != null && topLevelDoc.$__ && topLevelDoc.$populated(fullPath, true) && p < parts.length) {
+      if (topLevelDoc?.$__ && topLevelDoc.$populated(fullPath, true) && p < parts.length) {
         const model = topLevelDoc.$populated(fullPath, true).options[populateModelSymbol];
         if (model != null) {
           const ret = search(
@@ -198,7 +198,7 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
           leanPopulateMap.get(_val[0]) :
           leanPopulateMap.get(_val);
         // Populated using lean, `leanPopulateMap` value is the foreign model
-        const schema = model != null ? model.schema : null;
+        const schema = model?.schema ?? null;
         if (schema != null) {
           const ret = search(
             parts.slice(p),
@@ -218,7 +218,7 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
     }
   }
   // look for arrays
-  const parts = path.split('.');
+  parts = parts || path.split('.');
   for (let i = 0; i < parts.length; ++i) {
     if (parts[i] === '$') {
       // Re: gh-5628, because `schema.path()` doesn't take $ into account.

package/.output/server/node_modules/mongoose/lib/helpers/populate/markArraySubdocsPopulated.js

@@ -12,7 +12,7 @@ const utils = require('../../utils');
  *     doc.comments[0].populated('author'); // Should be set
  *
  * @param {Document} doc
- * @param {Object} [populated]
+ * @param {object} [populated]
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/populate/modelNamesFromRefPath.js

@@ -14,7 +14,11 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
     return [];
   }
 
-  if (typeof refPath === 'string' && queryProjection != null && isPathExcluded(queryProjection, refPath)) {
+  if (typeof refPath !== 'string') {
+    throw new MongooseError('`refPath` must be a string or a function that returns a string, got ' + util.inspect(refPath));
+  }
+
+  if (queryProjection != null && isPathExcluded(queryProjection, refPath)) {
     throw new MongooseError('refPath `' + refPath + '` must not be excluded in projection, got ' +
       util.inspect(queryProjection));
   }
@@ -35,7 +39,11 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
     // 2nd, 4th, etc. will be numeric props. For example: `[ 'a', '.0.', 'b' ]`
     for (let i = 0; i < chunks.length; i += 2) {
       const chunk = chunks[i];
-      if (_remaining.startsWith(chunk + '.')) {
+      if (
+        _remaining.length >= chunk.length + 1 &&
+        _remaining.charAt(chunk.length) === '.' &&
+        _remaining.slice(0, chunk.length) === chunk
+      ) {
         _refPath += _remaining.substring(0, chunk.length) + chunks[i + 1];
         _remaining = _remaining.substring(chunk.length + 1);
       } else if (i === chunks.length - 1) {