mongoose 9.9.2 → 9.9.3

package/lib/cast/double.js

@@ -30,6 +30,12 @@ module.exports = function castDouble(val) {
       assert.ok(false);
     }
   } else if (typeof val === 'object') {
+    if (Array.isArray(val)) {
+      // `[5].valueOf()` returns the array itself, so without this guard a
+      // single-element or empty array would fall through to `Number(tempVal)`
+      // below and silently coerce instead of throwing.
+      assert.ok(false);
+    }
     const tempVal = val.valueOf() ?? val.toString();
     // ex: { a: 'im an object, valueOf: () => 'helloworld' } // throw an error
     if (typeof tempVal === 'string') {

package/lib/cast/int32.js

@@ -20,6 +20,12 @@ module.exports = function castInt32(val) {
   if (val === '') {
     return null;
   }
+  if (Array.isArray(val)) {
+    // `Number([5])` is `5` and `Number([])` is `0`, so without this guard a
+    // single-element or empty array would silently coerce instead of throwing,
+    // unlike every other array input and unlike `castNumber()`'s own guard.
+    assert.ok(false);
+  }
 
   const coercedVal = isBsonType(val, 'Long') ? val.toNumber() : Number(val);
 

package/lib/document.js

@@ -2570,25 +2570,15 @@ Document.prototype.isSelected = function isSelected(path) {
     return path.some(p => this.$__isSelected(p));
   }
 
-  const paths = Object.keys(this.$__.selected);
-  let inclusive = null;
+  const index = _getProjectionIndex(this);
+  const paths = index.paths;
+  const inclusive = index.inclusive;
 
-  if (paths.length === 1 && paths[0] === '_id') {
+  if (index.onlyId) {
     // only _id was selected.
     return this.$__.selected._id === 0;
   }
 
-  for (const cur of paths) {
-    if (cur === '_id') {
-      continue;
-    }
-    if (!isDefiningProjection(this.$__.selected[cur])) {
-      continue;
-    }
-    inclusive = !!this.$__.selected[cur];
-    break;
-  }
-
   if (inclusive === null) {
     return true;
   }
@@ -2599,6 +2589,25 @@ Document.prototype.isSelected = function isSelected(path) {
 
   const pathHasDot = path.indexOf('.') !== -1;
 
+  if (!index.hasNestedKey) {
+    // No projection key is nested, so no key can start with `path + '.'` and
+    // only the "is an ancestor of `path` projected?" check below can match.
+    // Every ancestor that matches returns the same value, so we can walk
+    // `path`'s ancestors instead of scanning every projection key. This keeps
+    // `isSelected()` O(depth of path) rather than O(number of projected paths),
+    // which matters because `toObject({ getters: true })` calls this once per
+    // schema path. Re: gh-16373
+    if (pathHasDot) {
+      for (let dot = path.indexOf('.'); dot !== -1; dot = path.indexOf('.', dot + 1)) {
+        const ancestor = path.slice(0, dot);
+        if (ancestor !== '_id' && Object.hasOwn(this.$__.selected, ancestor)) {
+          return inclusive;
+        }
+      }
+    }
+    return !inclusive;
+  }
+
   for (const cur of paths) {
     if (cur === '_id') {
       continue;
@@ -2615,6 +2624,43 @@ Document.prototype.isSelected = function isSelected(path) {
   return !inclusive;
 };
 
+/*!
+ * Computes and caches the derived properties of `doc.$__.selected` that
+ * `isSelected()` and `isDirectSelected()` would otherwise recompute on every
+ * call. `$__.selected` is assigned once in the Document constructor and never
+ * mutated afterwards, so this can safely be cached for the document's lifetime.
+ */
+
+function _getProjectionIndex(doc) {
+  if (doc.$__.selectedIndex !== undefined) {
+    return doc.$__.selectedIndex;
+  }
+
+  const selected = doc.$__.selected;
+  const paths = Object.keys(selected);
+  let inclusive = null;
+  let hasNestedKey = false;
+
+  for (const cur of paths) {
+    if (cur === '_id') {
+      continue;
+    }
+    if (cur.indexOf('.') !== -1) {
+      hasNestedKey = true;
+    }
+    if (inclusive === null && isDefiningProjection(selected[cur])) {
+      inclusive = !!selected[cur];
+    }
+  }
+
+  return (doc.$__.selectedIndex = {
+    paths,
+    inclusive,
+    hasNestedKey,
+    onlyId: paths.length === 1 && paths[0] === '_id'
+  });
+}
+
 Document.prototype.$__isSelected = Document.prototype.isSelected;
 
 /**
@@ -2650,34 +2696,22 @@ Document.prototype.isDirectSelected = function isDirectSelected(path) {
     return path.some(p => this.isDirectSelected(p));
   }
 
-  const paths = Object.keys(this.$__.selected);
-  let inclusive = null;
+  const index = _getProjectionIndex(this);
 
-  if (paths.length === 1 && paths[0] === '_id') {
+  if (index.onlyId) {
     // only _id was selected.
     return this.$__.selected._id === 0;
   }
 
-  for (const cur of paths) {
-    if (cur === '_id') {
-      continue;
-    }
-    if (!isDefiningProjection(this.$__.selected[cur])) {
-      continue;
-    }
-    inclusive = !!this.$__.selected[cur];
-    break;
-  }
-
-  if (inclusive === null) {
+  if (index.inclusive === null) {
     return true;
   }
 
   if (Object.hasOwn(this.$__.selected, path)) {
-    return inclusive;
+    return index.inclusive;
   }
 
-  return !inclusive;
+  return !index.inclusive;
 };
 
 /**

package/lib/internal.js

@@ -17,6 +17,8 @@ InternalCache.prototype.strictMode = true;
 
 InternalCache.prototype.fullPath = undefined;
 InternalCache.prototype.selected = undefined;
+// Lazily computed index over `selected`, see `_getProjectionIndex()` in document.js
+InternalCache.prototype.selectedIndex = undefined;
 InternalCache.prototype.shardval = undefined;
 InternalCache.prototype.saveError = undefined;
 InternalCache.prototype.validationError = undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.9.2",
+  "version": "9.9.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",