@depup/mongoose 9.3.3-depup.0 → 9.8.0-depup.0

package/lib/queryHelpers.js

@@ -84,28 +84,29 @@ exports.createModel = function createModel(model, doc, fields, userProvidedField
     discriminatorMapping.key :
     null;
 
+  const _opts = {
+    skipId: true,
+    isNew: false,
+    willInit: true
+  };
+  if (options?.defaults != null) {
+    _opts.defaults = options.defaults;
+  }
+  if (options?.strict != null) {
+    _opts.strict = options.strict;
+  }
+
   const value = doc[key];
   if (key && value && model.discriminators) {
     const discriminator = model.discriminators[value] || getDiscriminatorByValue(model.discriminators, value);
     if (discriminator) {
       const _fields = clone(userProvidedFields);
       exports.applyPaths(_fields, discriminator.schema);
-      const _opts = { strict: options?.strict };
+
       return new discriminator(undefined, _fields, _opts);
     }
   }
 
-  const _opts = {
-    skipId: true,
-    isNew: false,
-    willInit: true
-  };
-  if (options != null && 'defaults' in options) {
-    _opts.defaults = options.defaults;
-  }
-  if (options != null && 'strict' in options) {
-    _opts.strict = options.strict;
-  }
   return new model(undefined, fields, _opts);
 };
 

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');
 
@@ -511,9 +510,9 @@ SchemaArray.prototype._castForQuery = function(val, context) {
   }
 
   if (Array.isArray(val)) {
-    this.setters.reverse().forEach(setter => {
-      val = setter.call(this, val, this);
-    });
+    for (let i = this.setters.length - 1; i >= 0; i--) {
+      val = this.setters[i].call(this, val, this);
+    }
     val = val.map(function(v) {
       if (utils.isObject(v) && v.$elemMatch) {
         return v;
@@ -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');
 
@@ -189,16 +188,18 @@ SchemaDate.prototype.expires = function(when) {
 SchemaDate._checkRequired = v => v instanceof Date;
 
 /**
- * Override the function the required validator uses to check whether a string
+ * Override the function the required validator uses to check whether a date
  * passes the `required` check.
  *
  * #### Example:
  *
- *     // Allow empty strings to pass `required` check
- *     mongoose.Schema.Types.String.checkRequired(v => v != null);
+ *     // Disallow "invalid date"
+ *     mongoose.Schema.Types.Date.checkRequired(v => v instanceof Date && !isNaN(v.valueOf()));
  *
- *     const M = mongoose.model({ str: { type: String, required: true } });
- *     new M({ str: '' }).validateSync(); // `null`, validation passes!
+ *     const schema = new mongoose.Schema({ myDate: { type: Date, required: true } });
+ *     const M = mongoose.model('Test', schema);
+ *     // returns a ValidationError due to date being invalid
+ *     new M({ myDate: new Date('invalid') }).validateSync();
  *
  * @param {Function} fn
  * @return {Function}
@@ -452,8 +453,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');
@@ -315,7 +314,7 @@ SchemaDocumentArray.prototype.doValidateSync = function(array, scope, options) {
       continue;
     }
 
-    const subdocValidateError = doc.validateSync(options);
+    const subdocValidateError = doc.$__validateSync(options);
 
     if (subdocValidateError && resultError == null) {
       resultError = subdocValidateError;
@@ -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;

package/lib/schema/number.js

@@ -8,7 +8,6 @@ const MongooseError = require('../error/index');
 const SchemaNumberOptions = require('../options/schemaNumberOptions');
 const SchemaType = require('../schemaType');
 const castNumber = require('../cast/number');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const handleBitwiseOperator = require('./operators/bitwise');
 const utils = require('../utils');
 
@@ -473,7 +472,7 @@ SchemaNumber.prototype.castForQuery = function($conditional, val, context) {
   if ($conditional != null) {
     handler = this.$conditionalHandlers[$conditional];
     if (!handler) {
-      throw new CastError('number', val, this.path, null, this);
+      throw new MongooseError('Can\'t use ' + $conditional + ' with Number.');
     }
     return handler.call(this, val, context);
   }
@@ -499,8 +498,7 @@ SchemaNumber.prototype.castForQuery = function($conditional, val, context) {
  */
 
 SchemaNumber.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = (this.options.required && typeof this.options.required !== 'function') || this.path === '_id';
-  return createJSONSchemaTypeDefinition('number', 'number', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('number', 'number', options);
 };
 
 /*!

package/lib/schema/objectId.js

@@ -7,7 +7,6 @@
 const SchemaObjectIdOptions = require('../options/schemaObjectIdOptions');
 const SchemaType = require('../schemaType');
 const castObjectId = require('../cast/objectid');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const getConstructorName = require('../helpers/getConstructorName');
 const oid = require('../types/objectid');
 const isBsonType = require('../helpers/isBsonType');
@@ -318,8 +317,13 @@ function resetId(v) {
  */
 
 SchemaObjectId.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = (this.options.required && typeof this.options.required !== 'function') || this.path === '_id';
-  return createJSONSchemaTypeDefinition('string', 'objectId', options?.useBsonType, isRequired);
+  const jsonSchema = this._createJSONSchemaTypeDefinition('string', 'objectId', options);
+  // `bsonType: 'objectId'` already validates ObjectIds, so the regex is only useful
+  // for the portable `type: 'string'` representation (e.g. for ajv, zod, etc.)
+  if (!options?.useBsonType) {
+    jsonSchema.pattern = '^[A-Fa-f0-9]{24}$';
+  }
+  return jsonSchema;
 };
 
 SchemaObjectId.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema/string.js

@@ -8,7 +8,6 @@ const SchemaType = require('../schemaType');
 const MongooseError = require('../error/index');
 const SchemaStringOptions = require('../options/schemaStringOptions');
 const castString = require('../cast/string');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const utils = require('../utils');
 const isBsonType = require('../helpers/isBsonType');
 
@@ -474,12 +473,14 @@ SchemaString.prototype.maxlength = function(value, message) {
 
   if (value != null) {
     let msg = message || MongooseError.messages.String.maxlength;
-    msg = msg.replace(/{MAXLENGTH}/, value);
+    if (typeof msg !== 'function') {
+      msg = msg.replace(/{MAXLENGTH}/, value);
+    }
     this.validators.push({
       validator: this.maxlengthValidator = function(v) {
         return v === null || v.length <= value;
       },
-      message: msg,
+      message: formatMaxLengthValidatorMessage(msg),
       type: 'maxlength',
       maxlength: value
     });
@@ -718,8 +719,7 @@ SchemaString.prototype.castForQuery = function($conditional, val, context) {
  */
 
 SchemaString.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('string', 'string', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('string', 'string', options);
 };
 
 SchemaString.prototype.autoEncryptionType = function autoEncryptionType() {
@@ -731,3 +731,18 @@ SchemaString.prototype.autoEncryptionType = function autoEncryptionType() {
  */
 
 module.exports = SchemaString;
+
+function formatMaxLengthValidatorMessage(msg) {
+  return function(props, doc) {
+    if (typeof msg === 'function') {
+      return MongooseError.ValidatorError.prototype.formatMessage(msg, props, doc);
+    }
+
+    if (typeof msg === 'string' && typeof props.value === 'string' && props.value.length > 30) {
+      props = Object.assign({}, props, {
+        value: props.value.slice(0, 30) + '...'
+      });
+    }
+    return MongooseError.ValidatorError.prototype.formatMessage(msg, props, doc);
+  };
+}

package/lib/schema/subdocument.js

@@ -12,7 +12,6 @@ const SchemaType = require('../schemaType');
 const applyDefaults = require('../helpers/document/applyDefaults');
 const $exists = require('./operators/exists');
 const castToNumber = require('./operators/helpers').castToNumber;
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const discriminator = require('../helpers/model/discriminator');
 const geospatial = require('./operators/geospatial');
 const getConstructor = require('../helpers/discriminator/getConstructor');
@@ -311,7 +310,7 @@ SchemaSubdocument.prototype.doValidateSync = function(value, scope, options) {
   if (!value) {
     return;
   }
-  return value.validateSync();
+  return value.$__validateSync();
 };
 
 /**
@@ -428,9 +427,8 @@ SchemaSubdocument.prototype.clone = function() {
  */
 
 SchemaSubdocument.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
   return {
     ...this.schema.toJSONSchema(options),
-    ...createJSONSchemaTypeDefinition('object', 'object', options?.useBsonType, isRequired)
+    ...this._createJSONSchemaTypeDefinition('object', 'object', options)
   };
 };

package/lib/schema/union.js

@@ -28,6 +28,7 @@ class Union extends SchemaType {
       throw new Error('Union schema type requires an array of types');
     }
     this.schemaTypes = options.of.map(obj => parentSchema.interpretAsType(key, obj, schemaOptions));
+    this.$isSchemaUnion = true;
   }
 
   cast(val, doc, init, prev, options) {
@@ -90,12 +91,61 @@ class Union extends SchemaType {
     throw lastError;
   }
 
+  async doValidate(value, scope, options) {
+    if (options && options.skipSchemaValidators) {
+      if (value != null && typeof value.validate === 'function') {
+        return value.validate();
+      }
+      return;
+    }
+
+    await super.doValidate(value, scope, options);
+    if (value != null && typeof value.validate === 'function') {
+      await value.validate();
+    }
+  }
+
+  doValidateSync(value, scope, options) {
+    if (!options || !options.skipSchemaValidators) {
+      const schemaTypeError = super.doValidateSync(value, scope, options);
+      if (schemaTypeError) {
+        return schemaTypeError;
+      }
+    }
+    if (value != null && typeof value.$__validateSync === 'function') {
+      return value.$__validateSync();
+    }
+  }
+
   clone() {
     const schematype = super.clone();
 
     schematype.schemaTypes = this.schemaTypes.map(schemaType => schemaType.clone());
     return schematype;
   }
+
+  /**
+   * Returns this schema type's representation in a JSON schema.
+   *
+   * @param {object} [options]
+   * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+   * @returns {object} JSON schema properties
+   */
+  toJSONSchema(options) {
+    const isRequired = this.options.required && typeof this.options.required !== 'function';
+    const childOptions = { ...options, _overrideRequired: true };
+    const jsonSchemas = this.schemaTypes.map(schemaType => schemaType.toJSONSchema(childOptions));
+    if (isRequired) {
+      return { anyOf: jsonSchemas };
+    }
+
+    return {
+      anyOf: [
+        options?.useBsonType ? { bsonType: 'null' } : { type: 'null' },
+        ...jsonSchemas
+      ]
+    };
+  }
 }
 
 /**

package/lib/schema/uuid.js

@@ -7,7 +7,6 @@
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castUUID = require('../cast/uuid');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const utils = require('../utils');
 const handleBitwiseOperator = require('./operators/bitwise');
 
@@ -290,8 +289,7 @@ SchemaUUID.prototype.castForQuery = function($conditional, val, context) {
  */
 
 SchemaUUID.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);
 };
 
 SchemaUUID.prototype.autoEncryptionType = function autoEncryptionType() {

package/lib/schema.js

@@ -59,7 +59,7 @@ const numberRE = /^\d+$/;
  * - [autoIndex](https://mongoosejs.com/docs/guide.html#autoIndex): bool - defaults to null (which means use the connection's autoIndex option)
  * - [autoCreate](https://mongoosejs.com/docs/guide.html#autoCreate): bool - defaults to null (which means use the connection's autoCreate option)
  * - [bufferCommands](https://mongoosejs.com/docs/guide.html#bufferCommands): bool - defaults to true
- * - [bufferTimeoutMS](https://mongoosejs.com/docs/guide.html#bufferTimeoutMS): number - defaults to 10000 (10 seconds). If `bufferCommands` is enabled, the amount of time Mongoose will wait for connectivity to be restablished before erroring out.
+ * - [bufferTimeoutMS](https://mongoosejs.com/docs/guide.html#bufferTimeoutMS): number - defaults to 10000 (10 seconds). If `bufferCommands` is enabled, the amount of time Mongoose will wait for connectivity to be established before erroring out.
  * - [capped](https://mongoosejs.com/docs/guide.html#capped): bool | number | object - defaults to false
  * - [collection](https://mongoosejs.com/docs/guide.html#collection): string - no default
  * - [discriminatorKey](https://mongoosejs.com/docs/guide.html#discriminatorKey): string - defaults to `__t`
@@ -72,6 +72,7 @@ const numberRE = /^\d+$/;
  * - [shardKey](https://mongoosejs.com/docs/guide.html#shardKey): object - defaults to `null`
  * - [strict](https://mongoosejs.com/docs/guide.html#strict): bool - defaults to true
  * - [strictQuery](https://mongoosejs.com/docs/guide.html#strictQuery): bool - defaults to false
+ * - [strictRead](https://mongoosejs.com/docs/guide.html#strictRead): bool or 'throw' - defaults to false. If set to `true`, fields not in the schema will be stripped when hydrating documents from MongoDB. If set to `'throw'`, an error will be thrown when a field not in the schema is encountered during document hydration.
  * - [toJSON](https://mongoosejs.com/docs/guide.html#toJSON) - object - no default
  * - [toObject](https://mongoosejs.com/docs/guide.html#toObject) - object - no default
  * - [typeKey](https://mongoosejs.com/docs/guide.html#typeKey) - string - defaults to 'type'
@@ -606,10 +607,12 @@ Schema.prototype.defaultOptions = function(options) {
   const baseOptions = this.base?.options || {};
   const defaultStrict = baseOptions.strict ?? true;
   const defaultStrictQuery = baseOptions.strictQuery ?? false;
+  const defaultStrictRead = baseOptions.strictRead ?? false;
   const defaultId = baseOptions.id ?? true;
   options = {
     strict: defaultStrict,
     strictQuery: defaultStrictQuery,
+    strictRead: defaultStrictRead,
     bufferCommands: true,
     capped: false, // { size, max, autoIndexId }
     versionKey: '__v',
@@ -750,7 +753,7 @@ Schema.prototype.encryptionType = function encryptionType(encryptionType) {
     return this.options.encryptionType;
   }
   if (!(typeof encryptionType === 'string' || encryptionType === null)) {
-    throw new MongooseError('invalid `encryptionType`: ${encryptionType}');
+    throw new MongooseError(`invalid \`encryptionType\`: ${encryptionType}`);
   }
   this.options.encryptionType = encryptionType;
 };
@@ -1268,7 +1271,7 @@ reserved.collection = 1;
 
 Schema.prototype.path = function(path, obj) {
   if (obj === undefined) {
-    if (this.paths[path] != null) {
+    if (Object.hasOwn(this.paths, path)) {
       return this.paths[path];
     }
     // Convert to '.$' to check subpaths re: gh-6405
@@ -1296,9 +1299,15 @@ Schema.prototype.path = function(path, obj) {
       : undefined;
   }
 
+  const subpaths = path.indexOf('.') === -1 ? [path] : path.split('.');
+  const last = subpaths.pop();
+  if (utils.specialProperties.has(last)) {
+    throw new MongooseError('Cannot set special property `' + last + '` on a schema');
+  }
+
   // some path names conflict with document methods
-  const firstPieceOfPath = path.split('.')[0];
-  if (reserved[firstPieceOfPath] && !this.options.suppressReservedKeysWarning) {
+  const firstPieceOfPath = subpaths.length === 0 ? last : subpaths[0];
+  if (Object.hasOwn(reserved, firstPieceOfPath) && !this.options.suppressReservedKeysWarning) {
     const errorMessage = `\`${firstPieceOfPath}\` is a reserved schema pathname and may break some functionality. ` +
       'You are allowed to use it, but use at your own risk. ' +
       'To disable this warning pass `suppressReservedKeysWarning` as a schema option.';
@@ -1311,8 +1320,6 @@ Schema.prototype.path = function(path, obj) {
   }
 
   // update the tree
-  const subpaths = path.split(/\./);
-  const last = subpaths.pop();
   let branch = this.tree;
   let fullPath = '';
 
@@ -1536,7 +1543,7 @@ function getMapPath(schema, path) {
     } else if (val.schema && path.startsWith(cleanPath + '.')) {
       let remnant = path.slice(cleanPath.length + 1);
       remnant = remnant.slice(remnant.indexOf('.') + 1);
-      return val.schema.paths[remnant];
+      return val.schema.path(remnant);
     } else if (val.$isSchemaMap && path.startsWith(cleanPath + '.')) {
       let remnant = path.slice(cleanPath.length + 1);
       remnant = remnant.slice(remnant.indexOf('.') + 1);
@@ -3026,7 +3033,7 @@ Schema.prototype._getPathType = function(path) {
           };
         }
         return { schema: foundschema, pathType: 'real' };
-      } else if (p === parts.length && schema.nested[trypath]) {
+      } else if (p === parts.length && Object.hasOwn(schema.nested, trypath)) {
         return { schema: schema, pathType: 'nested' };
       }
     }
@@ -3089,8 +3096,27 @@ function isArrayFilter(piece) {
 
 Schema.prototype._preCompile = function _preCompile() {
   this.plugin(idGetter, { deduplicate: true });
+  _precomputeOptimisticConcurrency(this);
 };
 
+/*!
+ * Build precomputed sets for optimisticConcurrency include/exclude,
+ * expanding user-specified paths to include all schema subpaths so that
+ * lookups at save time are a simple `Set.has()`.
+ */
+
+function _precomputeOptimisticConcurrency(schema) {
+  const opt = schema.options.optimisticConcurrency;
+  if (!opt || opt === true) {
+    return;
+  }
+  if (Array.isArray(opt)) {
+    schema.options._optimisticConcurrencySet = new Set(opt);
+  } else if (Array.isArray(opt.exclude)) {
+    schema.options._optimisticConcurrencyExcludeSet = new Set(opt.exclude);
+  }
+}
+
 /**
  * Returns a JSON schema representation of this Schema.
  *
@@ -3102,12 +3128,12 @@ Schema.prototype._preCompile = function _preCompile() {
  * - `enum` for strings and numbers
  *
  * #### Example:
- *    const schema = new Schema({ name: String });
- *    // { required: ['_id'], properties: { name: { type: ['string', 'null'] }, _id: { type: 'string' } } }
- *    schema.toJSONSchema();
+ *     const schema = new Schema({ name: String });
+ *     // { required: ['_id'], properties: { name: { type: ['string', 'null'] }, _id: { type: 'string' } } }
+ *     schema.toJSONSchema();
  *
- *    // { required: ['_id'], properties: { name: { bsonType: ['string', 'null'] }, _id: { bsonType: 'objectId' } } }
- *    schema.toJSONSchema({ useBsonType: true });
+ *     // { required: ['_id'], properties: { name: { bsonType: ['string', 'null'] }, _id: { bsonType: 'objectId' } } }
+ *     schema.toJSONSchema({ useBsonType: true });
  *
  * @param {object} [options]
  * @param {boolean} [options.useBsonType=false] if true, specify each path's type using `bsonType` rather than `type` for MongoDB $jsonSchema support