mongoose 8.6.3 → 8.7.0

package/lib/cast.js

@@ -65,10 +65,11 @@ module.exports = function cast(schema, obj, options, context) {
       if (!Array.isArray(val)) {
         throw new CastError('Array', val, path);
       }
-      for (let k = 0; k < val.length; ++k) {
+      for (let k = val.length - 1; k >= 0; k--) {
         if (val[k] == null || typeof val[k] !== 'object') {
           throw new CastError('Object', val[k], path + '.' + k);
         }
+        const beforeCastKeysLength = Object.keys(val[k]).length;
         const discriminatorValue = val[k][schema.options.discriminatorKey];
         if (discriminatorValue == null) {
           val[k] = cast(schema, val[k], options, context);
@@ -76,6 +77,15 @@ module.exports = function cast(schema, obj, options, context) {
           const discriminatorSchema = getSchemaDiscriminatorByValue(context.schema, discriminatorValue);
           val[k] = cast(discriminatorSchema ? discriminatorSchema : schema, val[k], options, context);
         }
+
+        if (Object.keys(val[k]).length === 0 && beforeCastKeysLength !== 0) {
+          val.splice(k, 1);
+        }
+      }
+
+      // delete empty: {$or: []} -> {}
+      if (val.length === 0) {
+        delete obj[path];
       }
     } else if (path === '$where') {
       type = typeof val;

package/lib/connection.js

@@ -106,6 +106,15 @@ Object.setPrototypeOf(Connection.prototype, EventEmitter.prototype);
 
 Object.defineProperty(Connection.prototype, 'readyState', {
   get: function() {
+    // If connection thinks it is connected, but we haven't received a heartbeat in 2 heartbeat intervals,
+    // that likely means the connection is stale (potentially due to frozen AWS Lambda container)
+    if (
+      this._readyState === STATES.connected &&
+      this._lastHeartbeatAt != null &&
+      typeof this.client?.topology?.s?.description?.heartbeatFrequencyMS === 'number' &&
+      Date.now() - this._lastHeartbeatAt >= this.client.topology.s.description.heartbeatFrequencyMS * 2) {
+      return STATES.disconnected;
+    }
     return this._readyState;
   },
   set: function(val) {

package/lib/constants.js

@@ -34,3 +34,40 @@ const queryMiddlewareFunctions = queryOperations.concat([
 ]);
 
 exports.queryMiddlewareFunctions = queryMiddlewareFunctions;
+
+/*!
+ * ignore
+ */
+
+const aggregateMiddlewareFunctions = [
+  'aggregate'
+];
+
+exports.aggregateMiddlewareFunctions = aggregateMiddlewareFunctions;
+
+/*!
+ * ignore
+ */
+
+const modelMiddlewareFunctions = [
+  'bulkWrite',
+  'createCollection',
+  'insertMany'
+];
+
+exports.modelMiddlewareFunctions = modelMiddlewareFunctions;
+
+/*!
+ * ignore
+ */
+
+const documentMiddlewareFunctions = [
+  'validate',
+  'save',
+  'remove',
+  'updateOne',
+  'deleteOne',
+  'init'
+];
+
+exports.documentMiddlewareFunctions = documentMiddlewareFunctions;

package/lib/document.js

@@ -2689,7 +2689,7 @@ function _evaluateRequiredFunctions(doc) {
  * ignore
  */
 
-function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
+function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate) {
   const doValidateOptions = {};
 
   _evaluateRequiredFunctions(doc);
@@ -2709,35 +2709,40 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
   Object.keys(doc.$__.activePaths.getStatePaths('default')).forEach(addToPaths);
   function addToPaths(p) { paths.add(p); }
 
-  const subdocs = doc.$getAllSubdocs();
-  const modifiedPaths = doc.modifiedPaths();
-  for (const subdoc of subdocs) {
-    if (subdoc.$basePath) {
-      const fullPathToSubdoc = subdoc.$isSingleNested ? subdoc.$__pathRelativeToParent() : subdoc.$__fullPathWithIndexes();
-
-      // 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()) {
-        paths.delete(fullPathToSubdoc + '.' + modifiedPath);
-      }
+  if (!isNestedValidate) {
+    // If we're validating a subdocument, all this logic will run anyway on the top-level document, so skip for subdocuments
+    const subdocs = doc.$getAllSubdocs();
+    const modifiedPaths = doc.modifiedPaths();
+    for (const subdoc of subdocs) {
+      if (subdoc.$basePath) {
+        const fullPathToSubdoc = subdoc.$isSingleNested ? subdoc.$__pathRelativeToParent() : subdoc.$__fullPathWithIndexes();
+
+        // 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()) {
+          paths.delete(fullPathToSubdoc + '.' + modifiedPath);
+        }
 
-      if (doc.$isModified(fullPathToSubdoc, null, modifiedPaths) &&
-            !doc.isDirectModified(fullPathToSubdoc) &&
-            !doc.$isDefault(fullPathToSubdoc)) {
-        paths.add(fullPathToSubdoc);
+        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
+              !doc.$__.activePaths.getStatePaths('modify').hasOwnProperty(fullPathToSubdoc) &&
+              !doc.$isDefault(fullPathToSubdoc)) {
+          paths.add(fullPathToSubdoc);
 
-        if (doc.$__.pathsToScopes == null) {
-          doc.$__.pathsToScopes = {};
-        }
-        doc.$__.pathsToScopes[fullPathToSubdoc] = subdoc.$isDocumentArrayElement ?
-          subdoc.__parentArray :
-          subdoc.$parent();
+          if (doc.$__.pathsToScopes == null) {
+            doc.$__.pathsToScopes = {};
+          }
+          doc.$__.pathsToScopes[fullPathToSubdoc] = subdoc.$isDocumentArrayElement ?
+            subdoc.__parentArray :
+            subdoc.$parent();
 
-        doValidateOptions[fullPathToSubdoc] = { skipSchemaValidators: true };
-        if (subdoc.$isDocumentArrayElement && subdoc.__index != null) {
-          doValidateOptions[fullPathToSubdoc].index = subdoc.__index;
+          doValidateOptions[fullPathToSubdoc] = { skipSchemaValidators: true };
+          if (subdoc.$isDocumentArrayElement && subdoc.__index != null) {
+            doValidateOptions[fullPathToSubdoc].index = subdoc.__index;
+          }
         }
       }
     }
@@ -2972,7 +2977,7 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
     paths = [...paths];
     doValidateOptionsByPath = {};
   } else {
-    const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip);
+    const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip, options && options._nestedValidate);
     paths = shouldValidateModifiedOnly ?
       pathDetails[0].filter((path) => this.$isModified(path)) :
       pathDetails[0];
@@ -3059,7 +3064,8 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
       const doValidateOptions = {
         ...doValidateOptionsByPath[path],
         path: path,
-        validateAllPaths
+        validateAllPaths,
+        _nestedValidate: true
       };
 
       schemaType.doValidate(val, function(err) {
@@ -3478,44 +3484,9 @@ Document.prototype.$__reset = function reset() {
   // Skip for subdocuments
   const subdocs = !this.$isSubdocument ? this.$getAllSubdocs() : null;
   if (subdocs && subdocs.length > 0) {
-    const resetArrays = new Set();
     for (const subdoc of subdocs) {
-      const fullPathWithIndexes = subdoc.$__fullPathWithIndexes();
       subdoc.$__reset();
-      if (this.isModified(fullPathWithIndexes) || isParentInit(fullPathWithIndexes)) {
-        if (subdoc.$isDocumentArrayElement) {
-          resetArrays.add(subdoc.parentArray());
-        } else {
-          const parent = subdoc.$parent();
-          if (parent === this) {
-            this.$__.activePaths.clearPath(subdoc.$basePath);
-          } else if (parent != null && parent.$isSubdocument) {
-            // If map path underneath subdocument, may end up with a case where
-            // map path is modified but parent still needs to be reset. See gh-10295
-            parent.$__reset();
-          }
-        }
-      }
-    }
-
-    for (const array of resetArrays) {
-      this.$__.activePaths.clearPath(array.$path());
-      array[arrayAtomicsBackupSymbol] = array[arrayAtomicsSymbol];
-      array[arrayAtomicsSymbol] = {};
-    }
-  }
-
-  function isParentInit(path) {
-    path = path.indexOf('.') === -1 ? [path] : path.split('.');
-    let cur = '';
-    for (let i = 0; i < path.length; ++i) {
-      cur += (cur.length ? '.' : '') + path[i];
-      if (_this.$__.activePaths[cur] === 'init') {
-        return true;
-      }
     }
-
-    return false;
   }
 
   // clear atomics

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

@@ -23,6 +23,11 @@ const utils = require('../../utils');
 function NativeConnection() {
   MongooseConnection.apply(this, arguments);
   this._listening = false;
+  // Tracks the last time (as unix timestamp) the connection received a
+  // serverHeartbeatSucceeded or serverHeartbeatFailed event from the underlying MongoClient.
+  // If we haven't received one in a while (like due to a frozen AWS Lambda container) then
+  // `readyState` is likely stale.
+  this._lastHeartbeatAt = null;
 }
 
 /**
@@ -106,6 +111,7 @@ NativeConnection.prototype.useDb = function(name, options) {
       _opts.noListener = options.noListener;
     }
     newConn.db = _this.client.db(name, _opts);
+    newConn._lastHeartbeatAt = _this._lastHeartbeatAt;
     newConn.onOpen();
   }
 
@@ -409,6 +415,9 @@ function _setClient(conn, client, options, dbName) {
       }
     });
   }
+  client.on('serverHeartbeatSucceeded', () => {
+    conn._lastHeartbeatAt = Date.now();
+  });
 
   if (options.monitorCommands) {
     client.on('commandStarted', (data) => conn.emit('commandStarted', data));
@@ -417,6 +426,9 @@ function _setClient(conn, client, options, dbName) {
   }
 
   conn.onOpen();
+  if (client.topology?.s?.state === 'connected') {
+    conn._lastHeartbeatAt = Date.now();
+  }
 
   for (const i in conn.collections) {
     if (utils.object.hasOwnProperty(conn.collections, i)) {

package/lib/error/browserMissingSchema.js

@@ -6,11 +6,12 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * MissingSchema Error constructor.
+ */
 
 class MissingSchemaError extends MongooseError {
-  /**
-   * MissingSchema Error constructor.
-   */
+
   constructor() {
     super('Schema hasn\'t been registered for document.\n'
       + 'Use mongoose.Document(name, schema)');

package/lib/error/bulkSaveIncompleteError.js

@@ -0,0 +1,44 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const MongooseError = require('./mongooseError');
+
+
+/**
+ * If the underwriting `bulkWrite()` for `bulkSave()` succeeded, but wasn't able to update or
+ * insert all documents, we throw this error.
+ *
+ * @api private
+ */
+
+class MongooseBulkSaveIncompleteError extends MongooseError {
+  constructor(modelName, documents, bulkWriteResult) {
+    const matchedCount = bulkWriteResult?.matchedCount ?? 0;
+    const insertedCount = bulkWriteResult?.insertedCount ?? 0;
+    let preview = documents.map(doc => doc._id).join(', ');
+    if (preview.length > 100) {
+      preview = preview.slice(0, 100) + '...';
+    }
+
+    const numDocumentsNotUpdated = documents.length - matchedCount - insertedCount;
+    super(`${modelName}.bulkSave() was not able to update ${numDocumentsNotUpdated} of the given documents due to incorrect version or optimistic concurrency, document ids: ${preview}`);
+
+    this.modelName = modelName;
+    this.documents = documents;
+    this.bulkWriteResult = bulkWriteResult;
+    this.numDocumentsNotUpdated = numDocumentsNotUpdated;
+  }
+}
+
+Object.defineProperty(MongooseBulkSaveIncompleteError.prototype, 'name', {
+  value: 'MongooseBulkSaveIncompleteError'
+});
+
+/*!
+ * exports
+ */
+
+module.exports = MongooseBulkSaveIncompleteError;

package/lib/error/divergentArray.js

@@ -7,12 +7,14 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * DivergentArrayError constructor.
+ * @param {Array<String>} paths
+ * @api private
+ */
+
 class DivergentArrayError extends MongooseError {
-  /**
-   * DivergentArrayError constructor.
-   * @param {Array<String>} paths
-   * @api private
-   */
+
   constructor(paths) {
     const msg = 'For your own good, using `document.save()` to update an array '
             + 'which was selected using an $elemMatch projection OR '

package/lib/error/invalidSchemaOption.js

@@ -7,12 +7,14 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * InvalidSchemaOption Error constructor.
+ * @param {String} name
+ * @api private
+ */
+
 class InvalidSchemaOptionError extends MongooseError {
-  /**
-   * InvalidSchemaOption Error constructor.
-   * @param {String} name
-   * @api private
-   */
+
   constructor(name, option) {
     const msg = `Cannot create use schema for property "${name}" because the schema has the ${option} option enabled.`;
     super(msg);

package/lib/error/missingSchema.js

@@ -7,12 +7,14 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * MissingSchema Error constructor.
+ * @param {String} name
+ * @api private
+ */
+
 class MissingSchemaError extends MongooseError {
-  /**
-   * MissingSchema Error constructor.
-   * @param {String} name
-   * @api private
-   */
+
   constructor(name) {
     const msg = 'Schema hasn\'t been registered for model "' + name + '".\n'
             + 'Use mongoose.model(name, schema)';

package/lib/error/notFound.js

@@ -7,11 +7,13 @@
 const MongooseError = require('./mongooseError');
 const util = require('util');
 
+/**
+ * OverwriteModel Error constructor.
+ * @api private
+ */
+
 class DocumentNotFoundError extends MongooseError {
-  /**
-   * OverwriteModel Error constructor.
-   * @api private
-   */
+
   constructor(filter, model, numAffected, result) {
     let msg;
     const messages = MongooseError.messages;

package/lib/error/objectExpected.js

@@ -6,15 +6,16 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * Strict mode error constructor
+ *
+ * @param {string} type
+ * @param {string} value
+ * @api private
+ */
 
 class ObjectExpectedError extends MongooseError {
-  /**
-   * Strict mode error constructor
-   *
-   * @param {string} type
-   * @param {string} value
-   * @api private
-   */
+
   constructor(path, val) {
     const typeDescription = Array.isArray(val) ? 'array' : 'primitive value';
     super('Tried to set nested object field `' + path +

package/lib/error/objectParameter.js

@@ -6,16 +6,18 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * Constructor for errors that happen when a parameter that's expected to be
+ * an object isn't an object
+ *
+ * @param {Any} value
+ * @param {String} paramName
+ * @param {String} fnName
+ * @api private
+ */
+
 class ObjectParameterError extends MongooseError {
-  /**
-   * Constructor for errors that happen when a parameter that's expected to be
-   * an object isn't an object
-   *
-   * @param {Any} value
-   * @param {String} paramName
-   * @param {String} fnName
-   * @api private
-   */
+
   constructor(value, paramName, fnName) {
     super('Parameter "' + paramName + '" to ' + fnName +
       '() must be an object, got "' + value.toString() + '" (type ' + typeof value + ')');

package/lib/error/overwriteModel.js

@@ -7,13 +7,14 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * OverwriteModel Error constructor.
+ * @param {String} name
+ * @api private
+ */
 
 class OverwriteModelError extends MongooseError {
-  /**
-   * OverwriteModel Error constructor.
-   * @param {String} name
-   * @api private
-   */
+
   constructor(name) {
     super('Cannot overwrite `' + name + '` model once compiled.');
   }

package/lib/error/parallelSave.js

@@ -6,13 +6,16 @@
 
 const MongooseError = require('./mongooseError');
 
+
+/**
+ * ParallelSave Error constructor.
+ *
+ * @param {Document} doc
+ * @api private
+ */
+
 class ParallelSaveError extends MongooseError {
-  /**
-   * ParallelSave Error constructor.
-   *
-   * @param {Document} doc
-   * @api private
-   */
+
   constructor(doc) {
     const msg = 'Can\'t save() the same doc multiple times in parallel. Document: ';
     super(msg + doc._doc._id);

package/lib/error/parallelValidate.js

@@ -7,13 +7,15 @@
 const MongooseError = require('./mongooseError');
 
 
+/**
+ * ParallelValidate Error constructor.
+ *
+ * @param {Document} doc
+ * @api private
+ */
+
 class ParallelValidateError extends MongooseError {
-  /**
-   * ParallelValidate Error constructor.
-   *
-   * @param {Document} doc
-   * @api private
-   */
+
   constructor(doc) {
     const msg = 'Can\'t validate() the same doc multiple times in parallel. Document: ';
     super(msg + doc._doc._id);

package/lib/error/setOptionError.js

@@ -8,13 +8,15 @@ const MongooseError = require('./mongooseError');
 const util = require('util');
 const combinePathErrors = require('../helpers/error/combinePathErrors');
 
+/**
+ * Mongoose.set Error
+ *
+ * @api private
+ * @inherits MongooseError
+ */
+
 class SetOptionError extends MongooseError {
-  /**
-   * Mongoose.set Error
-   *
-   * @api private
-   * @inherits MongooseError
-   */
+
   constructor() {
     super('');
 

package/lib/error/strict.js

@@ -6,17 +6,19 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * Strict mode error constructor
+ *
+ * @param {String} path
+ * @param {String} [msg]
+ * @param {Boolean} [immutable]
+ * @inherits MongooseError
+ * @api private
+ */
+
 
 class StrictModeError extends MongooseError {
-  /**
-   * Strict mode error constructor
-   *
-   * @param {String} path
-   * @param {String} [msg]
-   * @param {Boolean} [immutable]
-   * @inherits MongooseError
-   * @api private
-   */
+
   constructor(path, msg, immutable) {
     msg = msg || 'Field `' + path + '` is not in schema and strict ' +
       'mode is set to throw.';

package/lib/error/strictPopulate.js

@@ -6,15 +6,17 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * Strict mode error constructor
+ *
+ * @param {String} path
+ * @param {String} [msg]
+ * @inherits MongooseError
+ * @api private
+ */
+
 class StrictPopulateError extends MongooseError {
-  /**
-   * Strict mode error constructor
-   *
-   * @param {String} path
-   * @param {String} [msg]
-   * @inherits MongooseError
-   * @api private
-   */
+
   constructor(path, msg) {
     msg = msg || 'Cannot populate path `' + path + '` because it is not in your schema. ' + 'Set the `strictPopulate` option to false to override.';
     super(msg);

package/lib/error/validation.js

@@ -9,14 +9,16 @@ const getConstructorName = require('../helpers/getConstructorName');
 const util = require('util');
 const combinePathErrors = require('../helpers/error/combinePathErrors');
 
+/**
+ * Document Validation Error
+ *
+ * @api private
+ * @param {Document} [instance]
+ * @inherits MongooseError
+ */
+
 class ValidationError extends MongooseError {
-  /**
-   * Document Validation Error
-   *
-   * @api private
-   * @param {Document} [instance]
-   * @inherits MongooseError
-   */
+
   constructor(instance) {
     let _message;
     if (getConstructorName(instance) === 'model') {

package/lib/error/validator.js

@@ -6,15 +6,16 @@
 
 const MongooseError = require('./mongooseError');
 
+/**
+ * Schema validator error
+ *
+ * @param {Object} properties
+ * @param {Document} doc
+ * @api private
+ */
 
 class ValidatorError extends MongooseError {
-  /**
-   * Schema validator error
-   *
-   * @param {Object} properties
-   * @param {Document} doc
-   * @api private
-   */
+
   constructor(properties, doc) {
     let msg = properties.message;
     if (!msg) {