mongoose 9.3.3 → 9.4.0

package/lib/connection.js

@@ -1005,10 +1005,7 @@ Connection.prototype.error = function error(err, callback) {
 Connection.prototype.onOpen = function() {
   this.readyState = STATES.connected;
 
-  for (const d of this._queue) {
-    d.fn.apply(d.ctx, d.args);
-  }
-  this._queue = [];
+  this._flushQueue();
 
   // avoid having the collection subscribe to our event emitter
   // to prevent 0.3 warning
@@ -1021,6 +1018,21 @@ Connection.prototype.onOpen = function() {
   this.emit('open');
 };
 
+/**
+ * Flush all buffered operations in `_queue`. Called by `onOpen()` and
+ * by the heartbeat handler when a previously-stale connection recovers.
+ *
+ * @api private
+ */
+
+Connection.prototype._flushQueue = function _flushQueue() {
+  const queue = this._queue;
+  this._queue = [];
+  for (const d of queue) {
+    d.fn.apply(d.ctx, d.args);
+  }
+};
+
 /**
  * Opens the connection with a URI using `MongoClient.connect()`.
  *
@@ -1033,11 +1045,11 @@ Connection.prototype.onOpen = function() {
  * @param {string} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
  * @param {number} [options.maxPoolSize=100] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {number} [options.minPoolSize=0] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
- * @param {number} [options.serverSelectionTimeoutMS] If `useUnifiedTopology = true`, the MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
- * @param {number} [options.heartbeatFrequencyMS] If `useUnifiedTopology = true`, the MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
+ * @param {number} [options.serverSelectionTimeoutMS] The MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
+ * @param {number} [options.heartbeatFrequencyMS] The MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
  * @param {boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
  * @param {number} [options.socketTimeoutMS=0] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. `socketTimeoutMS` defaults to 0, which means Node.js will not time out the socket due to inactivity. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
- * @param {number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
+ * @param {number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
  * @param {boolean} [options.autoCreate=false] Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection.
  * @returns {Promise<Connection>}
  * @api public

package/lib/document.js

@@ -2981,9 +2981,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 +3079,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);
-    }
   }
 
 
@@ -3595,25 +3606,21 @@ 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.
+  this.$__resetAtomics();
 
   this.$__.backup = {};
   this.$__.backup.activePaths = {
@@ -3636,6 +3643,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
  */
@@ -4995,34 +5036,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.
  *

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

@@ -89,12 +89,11 @@ NativeCollection.prototype._getCollection = function _getCollection() {
 function iter(i) {
   NativeCollection.prototype[i] = function() {
     const collection = this._getCollection();
-    const args = Array.from(arguments);
+    const args = arguments;
     const _this = this;
     const globalDebug = _this?.conn?.base?.options?.debug;
     const connectionDebug = _this?.conn?.options?.debug;
     const debug = connectionDebug == null ? globalDebug : connectionDebug;
-    const opId = new ObjectId();
 
     // If user force closed, queueing will hang forever. See #5664
     if (this.conn.$wasForceClosed) {
@@ -108,9 +107,21 @@ function iter(i) {
       }
     }
 
+    // Lazily generate opId and argsArray only if necessary because they have
+    // a non-trivial performance cost.
+    let opId = null;
+    let argsArray = null;
+    const hasOperationListeners = this.conn.listenerCount('operation-start') > 0 || this.conn.listenerCount('operation-end') > 0;
+    if (hasOperationListeners || debug) {
+      opId = new ObjectId();
+    }
+
     let timeout = null;
     let waitForBufferPromise = null;
     if (this._shouldBufferCommands() && this.buffer) {
+      if (opId == null) {
+        opId = new ObjectId();
+      }
       this.conn.emit('buffer', {
         _id: opId,
         modelName: _this.modelName,
@@ -145,11 +156,14 @@ function iter(i) {
 
     if (debug) {
       if (typeof debug === 'function') {
+        if (argsArray == null) {
+          argsArray = Array.from(args);
+        }
         let argsToAdd = null;
-        if (typeof args[args.length - 1] == 'function') {
-          argsToAdd = args.slice(0, args.length - 1);
+        if (typeof argsArray[argsArray.length - 1] == 'function') {
+          argsToAdd = argsArray.slice(0, argsArray.length - 1);
         } else {
-          argsToAdd = args;
+          argsToAdd = argsArray;
         }
         debug.apply(_this,
           [_this.name, i].concat(argsToAdd));
@@ -162,7 +176,12 @@ function iter(i) {
       }
     }
 
-    this.conn.emit('operation-start', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, params: args });
+    if (hasOperationListeners) {
+      if (argsArray == null) {
+        argsArray = Array.from(args);
+      }
+      this.conn.emit('operation-start', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, params: argsArray });
+    }
 
     try {
       if (collection == null) {
@@ -179,20 +198,26 @@ function iter(i) {
             if (timeout != null) {
               clearTimeout(timeout);
             }
-            this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result });
+            if (hasOperationListeners) {
+              this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result });
+            }
             return result;
           },
           error => {
             if (timeout != null) {
               clearTimeout(timeout);
             }
-            this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error });
+            if (hasOperationListeners) {
+              this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error });
+            }
             throw error;
           }
         );
       }
 
-      this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result: ret });
+      if (hasOperationListeners) {
+        this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result: ret });
+      }
       if (timeout != null) {
         clearTimeout(timeout);
       }
@@ -201,7 +226,9 @@ function iter(i) {
       if (timeout != null) {
         clearTimeout(timeout);
       }
-      this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error: error });
+      if (hasOperationListeners) {
+        this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error: error });
+      }
       throw error;
     }
   };

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

@@ -14,6 +14,10 @@ const setTimeout = require('../../helpers/timers').setTimeout;
 const utils = require('../../utils');
 const Schema = require('../../schema');
 
+// Snapshot the native Date constructor to ensure Date.now()
+// bypasses timer mocks such as those set up by useFakeTimers().
+const Date = globalThis.Date;
+
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) connection implementation.
  *
@@ -482,6 +486,15 @@ function _setClient(conn, client, options, dbName) {
     for (const otherDb of conn.otherDbs) {
       otherDb._lastHeartbeatAt = conn._lastHeartbeatAt;
     }
+    // Flush buffered operations if the connection is no longer stale (gh-16183)
+    if (conn._queue.length > 0 && conn.readyState === STATES.connected) {
+      conn._flushQueue();
+    }
+    for (const otherDb of conn.otherDbs) {
+      if (otherDb._queue.length > 0 && otherDb.readyState === STATES.connected) {
+        otherDb._flushQueue();
+      }
+    }
   });
 
   if (options.monitorCommands) {

package/lib/error/index.js

@@ -32,7 +32,7 @@ const MongooseError = require('./mongooseError');
  * - `ValidationError`: error returned from [`validate()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()) or [`validateSync()`](https://mongoosejs.com/docs/api/document.html#Document.prototype.validateSync()). Contains zero or more `ValidatorError` instances in `.errors` property.
  * - `MissingSchemaError`: You called `mongoose.Document()` without a schema
  * - `ObjectExpectedError`: Thrown when you set a nested path to a non-object value with [strict mode set](https://mongoosejs.com/docs/guide.html#strict).
- * - `ObjectParameterError`: Thrown when you pass a non-object value to a function which expects an object as a paramter
+ * - `ObjectParameterError`: Thrown when you pass a non-object value to a function which expects an object as a parameter
  * - `OverwriteModelError`: Thrown when you call [`mongoose.model()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.model()) to re-define a model that was already defined.
  * - `ParallelSaveError`: Thrown when you call [`save()`](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) on a document when the same document instance is already saving.
  * - `StrictModeError`: Thrown when you set a path that isn't the schema and [strict mode](https://mongoosejs.com/docs/guide.html#strict) is set to `throw`.

package/lib/helpers/setDefaultsOnInsert.js

@@ -84,7 +84,7 @@ module.exports = function(filter, schema, castedDoc, options, queryMongooseOptio
     if (schemaType.path === '_id' && schemaType.options.auto) {
       return;
     }
-    const def = schemaType.getDefault(null, true, { context });
+    const def = schemaType.getDefault(null, false, { context });
     if (typeof def === 'undefined') {
       return;
     }

package/lib/model.js

@@ -189,8 +189,11 @@ Model.prototype.db;
  */
 
 Model.useConnection = function useConnection(connection) {
-  if (!connection) {
-    throw new MongooseError('Please provide a connection.');
+  if (typeof connection?.model !== 'function' || typeof connection.collection !== 'function' || typeof connection.base?.version !== 'string') {
+    throw new MongooseError('`useConnection()` requires a Mongoose connection.');
+  }
+  if (this.db?.base?.version && this.db?.base?.version !== connection.base?.version) {
+    throw new MongooseError(`The connection passed to \`useConnection()\` has a different version of Mongoose (${connection.base?.version}) than the model you are using (${this.db?.base?.version}).`);
   }
   if (this.db) {
     delete this.db.models[this.modelName];
@@ -635,7 +638,7 @@ Model.prototype.save = async function save(options) {
   if (this.$__.saving) {
     parallelSave = new ParallelSaveError(this);
   } else {
-    this.$__.saving = new ParallelSaveError(this);
+    this.$__.saving = true;
   }
 
   options = new SaveOptions(options);

package/lib/schema/array.js

@@ -21,7 +21,6 @@ const isOperator = require('../helpers/query/isOperator');
 const util = require('util');
 const utils = require('../utils');
 const castToNumber = require('./operators/helpers').castToNumber;
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const geospatial = require('./operators/geospatial');
 const getDiscriminatorByValue = require('../helpers/discriminator/getDiscriminatorByValue');
 
@@ -684,9 +683,8 @@ handle.$in = SchemaType.prototype.$conditionalHandlers.$in;
 
 SchemaArray.prototype.toJSONSchema = function toJSONSchema(options) {
   const embeddedSchemaType = this.getEmbeddedSchemaType();
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
   return {
-    ...createJSONSchemaTypeDefinition('array', 'array', options?.useBsonType, isRequired),
+    ...this._createJSONSchemaTypeDefinition('array', 'array', options),
     items: embeddedSchemaType.toJSONSchema(options)
   };
 };

package/lib/schema/bigint.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBigInt = require('../cast/bigint');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 
 /**
  * BigInt SchemaType constructor.
@@ -267,8 +266,7 @@ SchemaBigInt.prototype._castNullish = function _castNullish(v) {
  */
 
 SchemaBigInt.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('string', 'long', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('string', 'long', options);
 };
 
 SchemaBigInt.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/boolean.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castBoolean = require('../cast/boolean');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 
 /**
  * Boolean SchemaType constructor.
@@ -317,8 +316,7 @@ SchemaBoolean.prototype._castNullish = function _castNullish(v) {
  */
 
 SchemaBoolean.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('boolean', 'bool', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('boolean', 'bool', options);
 };
 
 SchemaBoolean.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/buffer.js

@@ -7,7 +7,6 @@
 const MongooseBuffer = require('../types/buffer');
 const SchemaBufferOptions = require('../options/schemaBufferOptions');
 const SchemaType = require('../schemaType');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const handleBitwiseOperator = require('./operators/bitwise');
 const utils = require('../utils');
 
@@ -328,8 +327,7 @@ SchemaBuffer.prototype.castForQuery = function($conditional, val, context) {
  */
 
 SchemaBuffer.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('string', 'binData', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('string', 'binData', options);
 };
 
 SchemaBuffer.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/date.js

@@ -8,7 +8,6 @@ const MongooseError = require('../error/index');
 const SchemaDateOptions = require('../options/schemaDateOptions');
 const SchemaType = require('../schemaType');
 const castDate = require('../cast/date');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const getConstructorName = require('../helpers/getConstructorName');
 const utils = require('../utils');
 
@@ -452,8 +451,7 @@ SchemaDate.prototype.castForQuery = function($conditional, val, context) {
  */
 
 SchemaDate.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('string', 'date', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('string', 'date', options);
 };
 
 SchemaDate.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/decimal128.js

@@ -7,7 +7,6 @@
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castDecimal128 = require('../cast/decimal128');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const isBsonType = require('../helpers/isBsonType');
 
 /**
@@ -248,8 +247,7 @@ Object.defineProperty(SchemaDecimal128.prototype, '$conditionalHandlers', {
  */
 
 SchemaDecimal128.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('string', 'decimal', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('string', 'decimal', options);
 };
 
 SchemaDecimal128.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/documentArray.js

@@ -12,7 +12,6 @@ const SchemaDocumentArrayOptions =
   require('../options/schemaDocumentArrayOptions');
 const SchemaType = require('../schemaType');
 const cast = require('../cast');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const discriminator = require('../helpers/model/discriminator');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
@@ -651,10 +650,9 @@ function cast$elemMatch(val, context) {
  */
 
 SchemaDocumentArray.prototype.toJSONSchema = function toJSONSchema(options) {
-  const itemsTypeDefinition = createJSONSchemaTypeDefinition('object', 'object', options?.useBsonType, false);
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  const itemsTypeDefinition = this._createJSONSchemaTypeDefinition('object', 'object', { ...options, _overrideRequired: false });
   return {
-    ...createJSONSchemaTypeDefinition('array', 'array', options?.useBsonType, isRequired),
+    ...this._createJSONSchemaTypeDefinition('array', 'array', options),
     items: { ...itemsTypeDefinition, ...this.schema.toJSONSchema(options) }
   };
 };

package/lib/schema/double.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castDouble = require('../cast/double');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 
 /**
  * Double SchemaType constructor.
@@ -231,8 +230,7 @@ Object.defineProperty(SchemaDouble.prototype, '$conditionalHandlers', {
  */
 
 SchemaDouble.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('number', 'double', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('number', 'double', options);
 };
 
 SchemaDouble.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/int32.js

@@ -7,7 +7,6 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castInt32 = require('../cast/int32');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const handleBitwiseOperator = require('./operators/bitwise');
 
 /**
@@ -273,8 +272,7 @@ SchemaInt32.prototype.castForQuery = function($conditional, val, context) {
  */
 
 SchemaInt32.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('number', 'int', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('number', 'int', options);
 };
 
 SchemaInt32.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/map.js

@@ -7,7 +7,6 @@
 const MongooseMap = require('../types/map');
 const SchemaMapOptions = require('../options/schemaMapOptions');
 const SchemaType = require('../schemaType');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const MongooseError = require('../error/mongooseError');
 const Schema = require('../schema');
 const utils = require('../utils');
@@ -125,11 +124,9 @@ class SchemaMap extends SchemaType {
    */
 
   toJSONSchema(options) {
-    const useBsonType = options?.useBsonType;
     const embeddedSchemaType = this.getEmbeddedSchemaType();
 
-    const isRequired = this.options.required && typeof this.options.required !== 'function';
-    const result = createJSONSchemaTypeDefinition('object', 'object', useBsonType, isRequired);
+    const result = this._createJSONSchemaTypeDefinition('object', 'object', options);
     result.additionalProperties = embeddedSchemaType.toJSONSchema(options);
 
     return result;