mongoose 9.0.0 → 9.0.2

package/lib/helpers/populate/modelNamesFromRefPath.js

@@ -56,7 +56,7 @@ module.exports = function modelNamesFromRefPath(refPath, doc, populatedPath, mod
   const refValue = mpath.get(refPath, doc, lookupLocalFields);
 
   let modelNames;
-  if (modelSchema != null && modelSchema.virtuals.hasOwnProperty(refPath)) {
+  if (modelSchema != null && Object.hasOwn(modelSchema.virtuals, refPath)) {
     modelNames = [modelSchema.virtuals[refPath].applyGetters(void 0, doc)];
   } else {
     modelNames = Array.isArray(refValue) ? refValue : [refValue];

package/lib/helpers/populate/removeDeselectedForeignField.js

@@ -16,7 +16,7 @@ module.exports = function removeDeselectedForeignField(foreignFields, options, d
     return;
   }
   for (const foreignField of foreignFields) {
-    if (!projection.hasOwnProperty('-' + foreignField)) {
+    if (!Object.hasOwn(projection, '-' + foreignField)) {
       continue;
     }
 

package/lib/helpers/projection/applyProjection.js

@@ -43,7 +43,7 @@ function applyExclusiveProjection(doc, projection, hasIncludedChildren, projecti
 
   for (const key of Object.keys(ret)) {
     const fullPath = prefix ? prefix + '.' + key : key;
-    if (projection.hasOwnProperty(fullPath) || projectionLimb.hasOwnProperty(key)) {
+    if (Object.hasOwn(projection, fullPath) || Object.hasOwn(projectionLimb, key)) {
       if (isPOJO(projection[fullPath]) || isPOJO(projectionLimb[key])) {
         ret[key] = applyExclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
       } else {
@@ -68,7 +68,7 @@ function applyInclusiveProjection(doc, projection, hasIncludedChildren, projecti
 
   for (const key of Object.keys(ret)) {
     const fullPath = prefix ? prefix + '.' + key : key;
-    if (projection.hasOwnProperty(fullPath) || projectionLimb.hasOwnProperty(key)) {
+    if (Object.hasOwn(projection, fullPath) || Object.hasOwn(projectionLimb, key)) {
       if (isPOJO(projection[fullPath]) || isPOJO(projectionLimb[key])) {
         ret[key] = applyInclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
       }

package/lib/helpers/query/getEmbeddedDiscriminatorPath.js

@@ -71,7 +71,7 @@ module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, p
         const schemaKey = updatedPathsByFilter[filterKey] + '.' + key;
         const arrayFilterKey = filterKey + '.' + key;
         if (schemaKey === discriminatorFilterPath) {
-          const filter = arrayFilters.find(filter => filter.hasOwnProperty(arrayFilterKey));
+          const filter = arrayFilters.find(filter => Object.hasOwn(filter, arrayFilterKey));
           if (filter != null) {
             discriminatorKey = filter[arrayFilterKey];
           }

package/lib/helpers/setDefaultsOnInsert.js

@@ -136,14 +136,14 @@ function pathExistsInUpdate(update, targetPath, pathPieces) {
   }
 
   // Check exact match
-  if (update.hasOwnProperty(targetPath)) {
+  if (Object.hasOwn(update, targetPath)) {
     return true;
   }
 
   // Check if any parent path exists
   let cur = pathPieces[0];
   for (let i = 1; i < pathPieces.length; ++i) {
-    if (update.hasOwnProperty(cur)) {
+    if (Object.hasOwn(update, cur)) {
       return true;
     }
     cur += '.' + pathPieces[i];

package/lib/helpers/timestamps/setupTimestamps.js

@@ -23,7 +23,7 @@ module.exports = function setupTimestamps(schema, timestamps) {
   }
   const createdAt = handleTimestampOption(timestamps, 'createdAt');
   const updatedAt = handleTimestampOption(timestamps, 'updatedAt');
-  const currentTime = timestamps != null && timestamps.hasOwnProperty('currentTime') ?
+  const currentTime = timestamps != null && Object.hasOwn(timestamps, 'currentTime') ?
     timestamps.currentTime :
     null;
   const schemaAdditions = {};

package/lib/helpers/update/applyTimestampsToUpdate.js

@@ -74,39 +74,52 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
       updates.$set[updatedAt] = now;
     }
 
-    if (updates.hasOwnProperty(updatedAt)) {
+    if (Object.hasOwn(updates, updatedAt)) {
       delete updates[updatedAt];
     }
   }
 
   if (!skipCreatedAt && createdAt) {
-    if (currentUpdate[createdAt]) {
-      delete currentUpdate[createdAt];
-    }
-    if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
-      delete currentUpdate.$set[createdAt];
-    }
-    let timestampSet = false;
-    if (createdAt.indexOf('.') !== -1) {
-      const pieces = createdAt.split('.');
-      for (let i = 1; i < pieces.length; ++i) {
-        const remnant = pieces.slice(-i).join('.');
-        const start = pieces.slice(0, -i).join('.');
-        if (currentUpdate[start] != null) {
-          currentUpdate[start][remnant] = now;
-          timestampSet = true;
-          break;
-        } else if (currentUpdate.$set && currentUpdate.$set[start]) {
-          currentUpdate.$set[start][remnant] = now;
-          timestampSet = true;
-          break;
+    const overwriteImmutable = get(options, 'overwriteImmutable', false);
+    const hasUserCreatedAt = currentUpdate[createdAt] != null || currentUpdate?.$set[createdAt] != null;
+
+    // If overwriteImmutable is true and user provided createdAt, keep their value
+    if (overwriteImmutable && hasUserCreatedAt) {
+      // Move createdAt from top-level to $set if needed
+      if (currentUpdate[createdAt] != null) {
+        updates.$set[createdAt] = currentUpdate[createdAt];
+        delete currentUpdate[createdAt];
+      }
+      // User's value is already in $set, nothing more to do
+    } else {
+      if (currentUpdate[createdAt]) {
+        delete currentUpdate[createdAt];
+      }
+      if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
+        delete currentUpdate.$set[createdAt];
+      }
+      let timestampSet = false;
+      if (createdAt.indexOf('.') !== -1) {
+        const pieces = createdAt.split('.');
+        for (let i = 1; i < pieces.length; ++i) {
+          const remnant = pieces.slice(-i).join('.');
+          const start = pieces.slice(0, -i).join('.');
+          if (currentUpdate[start] != null) {
+            currentUpdate[start][remnant] = now;
+            timestampSet = true;
+            break;
+          } else if (currentUpdate.$set && currentUpdate.$set[start]) {
+            currentUpdate.$set[start][remnant] = now;
+            timestampSet = true;
+            break;
+          }
         }
       }
-    }
 
-    if (!timestampSet) {
-      updates.$setOnInsert = updates.$setOnInsert || {};
-      updates.$setOnInsert[createdAt] = now;
+      if (!timestampSet) {
+        updates.$setOnInsert = updates.$setOnInsert || {};
+        updates.$setOnInsert[createdAt] = now;
+      }
     }
   }
 

package/lib/helpers/update/decorateUpdateWithVersionKey.js

@@ -31,5 +31,5 @@ function hasKey(obj, key) {
   if (obj == null || typeof obj !== 'object') {
     return false;
   }
-  return Object.prototype.hasOwnProperty.call(obj, key);
+  return Object.hasOwn(obj, key);
 }

package/lib/model.js

@@ -352,7 +352,7 @@ function _createSaveOptions(doc, options) {
   const asyncLocalStorage = doc[modelDbSymbol].base.transactionAsyncLocalStorage?.getStore();
   if (session != null) {
     saveOptions.session = session;
-  } else if (!options.hasOwnProperty('session') && asyncLocalStorage?.session != null) {
+  } else if (!Object.hasOwn(options, 'session') && asyncLocalStorage?.session != null) {
     // Only set session from asyncLocalStorage if `session` option wasn't originally passed in options
     saveOptions.session = asyncLocalStorage.session;
   }
@@ -586,7 +586,7 @@ Model.prototype.save = async function save(options) {
   }
 
   options = new SaveOptions(options);
-  if (options.hasOwnProperty('session')) {
+  if (Object.hasOwn(options, 'session')) {
     this.$session(options.session);
   }
   if (this.$__.timestamps != null) {
@@ -748,7 +748,7 @@ Model.prototype.deleteOne = function deleteOne(options) {
     options = {};
   }
 
-  if (options.hasOwnProperty('session')) {
+  if (Object.hasOwn(options, 'session')) {
     this.$session(options.session);
   }
 
@@ -2944,7 +2944,7 @@ Model.insertMany = async function insertMany(arr, options) {
   const lean = !!options.lean;
 
   const asyncLocalStorage = this.db.base.transactionAsyncLocalStorage?.getStore();
-  if ((!options || !options.hasOwnProperty('session')) && asyncLocalStorage?.session != null) {
+  if ((!options || !Object.hasOwn(options, 'session')) && asyncLocalStorage?.session != null) {
     options = { ...options, session: asyncLocalStorage.session };
   }
 
@@ -3248,12 +3248,14 @@ function _setIsNew(doc, val) {
  * @param {Object} [ops.updateOne.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
  * @param {Boolean} [ops.updateOne.upsert=false] If true, insert a doc if none match
  * @param {Boolean} [ops.updateOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {Boolean} [ops.updateOne.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
  * @param {Object} [ops.updateOne.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
  * @param {Array} [ops.updateOne.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
  * @param {Object} [ops.updateMany.filter] Update all the documents that match this filter
  * @param {Object} [ops.updateMany.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
  * @param {Boolean} [ops.updateMany.upsert=false] If true, insert a doc if no documents match `filter`
  * @param {Boolean} [ops.updateMany.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {Boolean} [ops.updateMany.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
  * @param {Object} [ops.updateMany.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
  * @param {Array} [ops.updateMany.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
  * @param {Object} [ops.deleteOne.filter] Delete the first document that matches this filter
@@ -3286,12 +3288,15 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
   }
   options = options || {};
 
-  [ops, options] = await this.hooks.execPre('bulkWrite', this, [ops, options]).catch(err => {
+  try {
+    [ops, options] = await this.hooks.execPre('bulkWrite', this, [ops, options]);
+  } catch (err) {
     if (err instanceof Kareem.skipWrappedFunction) {
-      return [err];
+      ops = err;
+    } else {
+      await this.hooks.execPost('bulkWrite', this, [null], { error: err });
     }
-    throw err;
-  });
+  }
 
   if (ops instanceof Kareem.skipWrappedFunction) {
     return ops.args[0];
@@ -3309,7 +3314,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
 
   const validations = options?._skipCastBulkWrite ? [] : ops.map(op => castBulkWrite(this, op, options));
   const asyncLocalStorage = this.db.base.transactionAsyncLocalStorage?.getStore();
-  if ((!options || !options.hasOwnProperty('session')) && asyncLocalStorage?.session != null) {
+  if ((!options || !Object.hasOwn(options, 'session')) && asyncLocalStorage?.session != null) {
     options = { ...options, session: asyncLocalStorage.session };
   }
 
@@ -3517,6 +3522,7 @@ async function handleSuccessfulWrite(document) {
   }
 
   document.$__reset();
+  document._applyVersionIncrement();
   return document.schema.s.hooks.execPost('save', document, [document]);
 }
 
@@ -4999,10 +5005,10 @@ Model._applyQueryMiddleware = function _applyQueryMiddleware() {
 
 function _getContexts(hook) {
   const ret = {};
-  if (hook.hasOwnProperty('query')) {
+  if (Object.hasOwn(hook, 'query')) {
     ret.query = hook.query;
   }
-  if (hook.hasOwnProperty('document')) {
+  if (Object.hasOwn(hook, 'document')) {
     ret.document = hook.document;
   }
   return ret;

package/lib/mongoose.js

@@ -601,12 +601,11 @@ Mongoose.prototype.model = function model(name, schema, collection, options) {
 
   // connection.model() may be passing a different schema for
   // an existing model name. in this case don't read from cache.
-  const overwriteModels = _mongoose.options.hasOwnProperty('overwriteModels') ?
+  const overwriteModels = Object.hasOwn(_mongoose.options, 'overwriteModels') ?
     _mongoose.options.overwriteModels :
     options.overwriteModels;
-  if (_mongoose.models.hasOwnProperty(name) && options.cache !== false && overwriteModels !== true) {
-    if (originalSchema &&
-        originalSchema.instanceOfSchema &&
+  if (Object.hasOwn(_mongoose.models, name) && options.cache !== false && overwriteModels !== true) {
+    if (originalSchema?.instanceOfSchema &&
         originalSchema !== _mongoose.models[name].schema) {
       throw new _mongoose.Error.OverwriteModelError(name);
     }

package/lib/query.js

@@ -2100,7 +2100,7 @@ Query.prototype._optionsForExec = function(model) {
   applyWriteConcern(model.schema, options);
 
   const asyncLocalStorage = this.model?.db?.base.transactionAsyncLocalStorage?.getStore();
-  if (!this.options.hasOwnProperty('session') && asyncLocalStorage?.session != null) {
+  if (!Object.hasOwn(this.options, 'session') && asyncLocalStorage?.session != null) {
     options.session = asyncLocalStorage.session;
   }
 
@@ -4595,7 +4595,7 @@ Query.prototype.exec = async function exec(op) {
     throw new MongooseError('Query has invalid `op`: "' + this.op + '"');
   }
 
-  if (this.options && this.options.sort && typeof this.options.sort === 'object' && this.options.sort.hasOwnProperty('')) {
+  if (this.options && this.options.sort && typeof this.options.sort === 'object' && Object.hasOwn(this.options.sort, '')) {
     throw new Error('Invalid field "" passed to sort()');
   }
 
@@ -4995,7 +4995,7 @@ Query.prototype.cast = function(model, obj) {
   model = model || this.model;
   const discriminatorKey = model.schema.options.discriminatorKey;
   if (obj != null &&
-      obj.hasOwnProperty(discriminatorKey)) {
+      Object.hasOwn(obj, discriminatorKey)) {
     model = getDiscriminatorByValue(model.discriminators, obj[discriminatorKey]) || model;
   }
 

package/lib/schema/array.js

@@ -80,7 +80,7 @@ function SchemaArray(key, cast, options, schemaOptions, parentSchema) {
       : utils.getFunctionName(cast);
 
     const Types = require('./index.js');
-    const schemaTypeDefinition = Types.hasOwnProperty(name) ? Types[name] : cast;
+    const schemaTypeDefinition = Object.hasOwn(Types, name) ? Types[name] : cast;
 
     if (typeof schemaTypeDefinition === 'function') {
       if (schemaTypeDefinition === SchemaArray) {

package/lib/schema/number.js

@@ -26,6 +26,7 @@ const CastError = SchemaType.CastError;
  */
 
 function SchemaNumber(key, options, _schemaOptions, parentSchema) {
+  this.enumValues = [];
   SchemaType.call(this, key, options, 'Number', parentSchema);
 }
 
@@ -316,8 +317,12 @@ SchemaNumber.prototype.enum = function(values, message) {
     this.validators = this.validators.filter(function(v) {
       return v.validator !== this.enumValidator;
     }, this);
+    this.enumValidator = false;
   }
 
+  if (values === void 0 || values === false) {
+    return this;
+  }
 
   if (!Array.isArray(values)) {
     const isObjectSyntax = utils.isPOJO(values) && values.values != null;
@@ -337,12 +342,19 @@ SchemaNumber.prototype.enum = function(values, message) {
 
   message = message == null ? MongooseError.messages.Number.enum : message;
 
-  this.enumValidator = v => v == null || values.indexOf(v) !== -1;
+  for (const value of values) {
+    if (value !== undefined) {
+      this.enumValues.push(this.cast(value));
+    }
+  }
+
+  const vals = this.enumValues;
+  this.enumValidator = v => v == null || vals.indexOf(v) !== -1;
   this.validators.push({
     validator: this.enumValidator,
     message: message,
     type: 'enum',
-    enumValues: values
+    enumValues: vals
   });
 
   return this;

package/lib/schema/operators/text.js

@@ -28,7 +28,7 @@ module.exports = function castTextSearch(val, path) {
   }
   if (val.$caseSensitive != null) {
     val.$caseSensitive = castBoolean(val.$caseSensitive,
-      path + '.$castSensitive');
+      path + '.$caseSensitive');
   }
   if (val.$diacriticSensitive != null) {
     val.$diacriticSensitive = castBoolean(val.$diacriticSensitive,

package/lib/schema.js

@@ -1485,17 +1485,17 @@ Schema.prototype._gatherChildSchemas = function _gatherChildSchemas() {
  */
 
 function _getPath(schema, path, cleanPath) {
-  if (schema.paths.hasOwnProperty(path)) {
+  if (Object.hasOwn(schema.paths, path)) {
     return schema.paths[path];
   }
-  if (schema.subpaths.hasOwnProperty(cleanPath)) {
+  if (Object.hasOwn(schema.subpaths, cleanPath)) {
     const subpath = schema.subpaths[cleanPath];
     if (subpath === 'nested') {
       return undefined;
     }
     return subpath;
   }
-  if (schema.singleNestedPaths.hasOwnProperty(cleanPath) && typeof schema.singleNestedPaths[cleanPath] === 'object') {
+  if (Object.hasOwn(schema.singleNestedPaths, cleanPath) && typeof schema.singleNestedPaths[cleanPath] === 'object') {
     const singleNestedPath = schema.singleNestedPaths[cleanPath];
     if (singleNestedPath === 'nested') {
       return undefined;
@@ -1683,20 +1683,20 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
           childSchemaOptions.typeKey = options.typeKey;
         }
         // propagate 'strict' option to child schema
-        if (options.hasOwnProperty('strict')) {
+        if (Object.hasOwn(options, 'strict')) {
           childSchemaOptions.strict = options.strict;
         }
-        if (options.hasOwnProperty('strictQuery')) {
+        if (Object.hasOwn(options, 'strictQuery')) {
           childSchemaOptions.strictQuery = options.strictQuery;
         }
-        if (options.hasOwnProperty('toObject')) {
+        if (Object.hasOwn(options, 'toObject')) {
           childSchemaOptions.toObject = utils.omit(options.toObject, ['transform']);
         }
-        if (options.hasOwnProperty('toJSON')) {
+        if (Object.hasOwn(options, 'toJSON')) {
           childSchemaOptions.toJSON = utils.omit(options.toJSON, ['transform']);
         }
 
-        if (this._userProvidedOptions.hasOwnProperty('_id')) {
+        if (Object.hasOwn(this._userProvidedOptions, '_id')) {
           childSchemaOptions._id = this._userProvidedOptions._id;
         } else if (Schema.Types.DocumentArray.defaultOptions._id != null) {
           childSchemaOptions._id = Schema.Types.DocumentArray.defaultOptions._id;
@@ -1733,7 +1733,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
           `Could not determine the embedded type for array \`${path}\`. ` +
           'See https://mongoosejs.com/docs/guide.html#definition for more info on supported schema syntaxes.');
       }
-      if (!MongooseTypes.hasOwnProperty(name)) {
+      if (!Object.hasOwn(MongooseTypes, name)) {
         throw new TypeError('Invalid schema configuration: ' +
           `\`${name}\` is not a valid type within the array \`${path}\`.` +
           'See https://bit.ly/mongoose-schematypes for a list of valid schema types.');
@@ -1894,24 +1894,24 @@ Schema.prototype.indexedPaths = function indexedPaths() {
  */
 
 Schema.prototype.pathType = function(path) {
-  if (this.paths.hasOwnProperty(path)) {
+  if (Object.hasOwn(this.paths, path)) {
     return 'real';
   }
-  if (this.virtuals.hasOwnProperty(path)) {
+  if (Object.hasOwn(this.virtuals, path)) {
     return 'virtual';
   }
-  if (this.nested.hasOwnProperty(path)) {
+  if (Object.hasOwn(this.nested, path)) {
     return 'nested';
   }
 
   // Convert to '.$' to check subpaths re: gh-6405
   const cleanPath = _pathToPositionalSyntax(path);
 
-  if (this.subpaths.hasOwnProperty(cleanPath) || this.subpaths.hasOwnProperty(path)) {
+  if (Object.hasOwn(this.subpaths, cleanPath) || Object.hasOwn(this.subpaths, path)) {
     return 'real';
   }
 
-  const singleNestedPath = this.singleNestedPaths.hasOwnProperty(cleanPath) || this.singleNestedPaths.hasOwnProperty(path);
+  const singleNestedPath = Object.hasOwn(this.singleNestedPaths, cleanPath) || Object.hasOwn(this.singleNestedPaths, path);
   if (singleNestedPath) {
     return singleNestedPath === 'nested' ? 'nested' : 'real';
   }
@@ -1941,7 +1941,7 @@ Schema.prototype.hasMixedParent = function(path) {
   path = '';
   for (let i = 0; i < subpaths.length; ++i) {
     path = i > 0 ? path + '.' + subpaths[i] : subpaths[i];
-    if (this.paths.hasOwnProperty(path) &&
+    if (Object.hasOwn(this.paths, path) &&
         this.paths[path] instanceof MongooseTypes.Mixed) {
       return this.paths[path];
     }
@@ -1970,7 +1970,7 @@ Schema.prototype.setupTimestamp = function(timestamps) {
 function getPositionalPathType(self, path, cleanPath) {
   const subpaths = path.split(/\.(\d+)\.|\.(\d+)$/).filter(Boolean);
   if (subpaths.length < 2) {
-    return self.paths.hasOwnProperty(subpaths[0]) ?
+    return Object.hasOwn(self.paths, subpaths[0]) ?
       self.paths[subpaths[0]] :
       'adhocOrUndefined';
   }
@@ -2675,7 +2675,7 @@ Schema.prototype.virtual = function(name, options) {
  */
 
 Schema.prototype.virtualpath = function(name) {
-  return this.virtuals.hasOwnProperty(name) ? this.virtuals[name] : null;
+  return Object.hasOwn(this.virtuals, name) ? this.virtuals[name] : null;
 };
 
 /**
@@ -2823,8 +2823,8 @@ Schema.prototype.loadClass = function(model, virtualsOnly) {
   // Stop copying when hit certain base classes
   if (model === Object.prototype ||
       model === Function.prototype ||
-      model.prototype.hasOwnProperty('$isMongooseModelPrototype') ||
-      model.prototype.hasOwnProperty('$isMongooseDocumentPrototype')) {
+      Object.hasOwn(model.prototype, '$isMongooseModelPrototype') ||
+      Object.hasOwn(model.prototype, '$isMongooseDocumentPrototype')) {
     return this;
   }
 
@@ -2837,7 +2837,7 @@ Schema.prototype.loadClass = function(model, virtualsOnly) {
         return;
       }
       const prop = Object.getOwnPropertyDescriptor(model, name);
-      if (prop.hasOwnProperty('value')) {
+      if (Object.hasOwn(prop, 'value')) {
         this.static(name, prop.value);
       }
     }, this);
@@ -3063,7 +3063,7 @@ Schema.prototype._transformDuplicateKeyError = function _transformDuplicateKeyEr
       return error;
     }
     const firstKey = keys[0];
-    if (!this._duplicateKeyErrorMessagesByPath.hasOwnProperty(firstKey)) {
+    if (!Object.hasOwn(this._duplicateKeyErrorMessagesByPath, firstKey)) {
       return error;
     }
     return new MongooseError(this._duplicateKeyErrorMessagesByPath[firstKey], { cause: error });

package/lib/schemaType.js

@@ -46,10 +46,10 @@ function SchemaType(path, options, instance, parentSchema) {
   this.instance = instance;
   this.schemaName = this.constructor.schemaName;
   this.validators = [];
-  this.getters = this.constructor.hasOwnProperty('getters') ?
+  this.getters = Object.hasOwn(this.constructor, 'getters') ?
     this.constructor.getters.slice() :
     [];
-  this.setters = this.constructor.hasOwnProperty('setters') ?
+  this.setters = Object.hasOwn(this.constructor, 'setters') ?
     this.constructor.setters.slice() :
     [];
 
@@ -62,7 +62,7 @@ function SchemaType(path, options, instance, parentSchema) {
   for (const option of defaultOptionsKeys) {
     if (option === 'validate') {
       this.validate(defaultOptions.validate);
-    } else if (defaultOptions.hasOwnProperty(option) && !Object.prototype.hasOwnProperty.call(options, option)) {
+    } else if (Object.hasOwn(defaultOptions, option) && !Object.hasOwn(options, option)) {
       options[option] = defaultOptions[option];
     }
   }
@@ -339,7 +339,7 @@ SchemaType.prototype.cast = function cast() {
  */
 
 SchemaType.set = function set(option, value) {
-  if (!this.hasOwnProperty('defaultOptions')) {
+  if (!Object.hasOwn(this, 'defaultOptions')) {
     this.defaultOptions = Object.assign({}, this.defaultOptions);
   }
   this.defaultOptions[option] = value;
@@ -362,7 +362,7 @@ SchemaType.set = function set(option, value) {
  */
 
 SchemaType.get = function(getter) {
-  this.getters = this.hasOwnProperty('getters') ? this.getters : [];
+  this.getters = Object.hasOwn(this, 'getters') ? this.getters : [];
   this.getters.push(getter);
 };
 
@@ -496,7 +496,7 @@ SchemaType.prototype.unique = function unique(value, message) {
       'false and `unique` set to true');
   }
 
-  if (!this.options.hasOwnProperty('index') && value === false) {
+  if (!Object.hasOwn(this.options, 'index') && value === false) {
     return this;
   }
 
@@ -535,7 +535,7 @@ SchemaType.prototype.text = function(bool) {
       'false and `text` set to true');
   }
 
-  if (!this.options.hasOwnProperty('index') && bool === false) {
+  if (!Object.hasOwn(this.options, 'index') && bool === false) {
     return this;
   }
 
@@ -572,7 +572,7 @@ SchemaType.prototype.sparse = function(bool) {
       'false and `sparse` set to true');
   }
 
-  if (!this.options.hasOwnProperty('index') && bool === false) {
+  if (!Object.hasOwn(this.options, 'index') && bool === false) {
     return this;
   }
 

package/lib/types/array/index.js

@@ -79,13 +79,13 @@ function MongooseArray(values, path, doc, schematype) {
 
   const proxy = new Proxy(__array, {
     get: function(target, prop) {
-      if (internals.hasOwnProperty(prop)) {
+      if (Object.hasOwn(internals, prop)) {
         return internals[prop];
       }
-      if (mongooseArrayMethods.hasOwnProperty(prop)) {
+      if (Object.hasOwn(mongooseArrayMethods, prop)) {
         return mongooseArrayMethods[prop];
       }
-      if (schematype && schematype.virtuals && schematype.virtuals.hasOwnProperty(prop)) {
+      if (schematype && schematype.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
         return schematype.virtuals[prop].applyGetters(undefined, target);
       }
       if (typeof prop === 'string' && numberRE.test(prop) && schematype?.embeddedSchemaType != null) {
@@ -97,9 +97,9 @@ function MongooseArray(values, path, doc, schematype) {
     set: function(target, prop, value) {
       if (typeof prop === 'string' && numberRE.test(prop)) {
         mongooseArrayMethods.set.call(proxy, prop, value, false);
-      } else if (internals.hasOwnProperty(prop)) {
+      } else if (Object.hasOwn(internals, prop)) {
         internals[prop] = value;
-      } else if (schematype && schematype.virtuals && schematype.virtuals.hasOwnProperty(prop)) {
+      } else if (schematype?.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
         schematype.virtuals[prop].applySetters(value, target);
       } else {
         __array[prop] = value;

package/lib/types/documentArray/index.js

@@ -73,16 +73,16 @@ function MongooseDocumentArray(values, path, doc, schematype) {
           prop === 'isMongooseDocumentArrayProxy') {
         return true;
       }
-      if (internals.hasOwnProperty(prop)) {
+      if (Object.hasOwn(internals, prop)) {
         return internals[prop];
       }
-      if (DocumentArrayMethods.hasOwnProperty(prop)) {
+      if (Object.hasOwn(DocumentArrayMethods, prop)) {
         return DocumentArrayMethods[prop];
       }
-      if (schematype && schematype.virtuals && schematype.virtuals.hasOwnProperty(prop)) {
+      if (schematype && schematype.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
         return schematype.virtuals[prop].applyGetters(undefined, target);
       }
-      if (ArrayMethods.hasOwnProperty(prop)) {
+      if (Object.hasOwn(ArrayMethods, prop)) {
         return ArrayMethods[prop];
       }
 
@@ -91,9 +91,9 @@ function MongooseDocumentArray(values, path, doc, schematype) {
     set: function(target, prop, value) {
       if (typeof prop === 'string' && numberRE.test(prop)) {
         DocumentArrayMethods.set.call(proxy, prop, value, false);
-      } else if (internals.hasOwnProperty(prop)) {
+      } else if (Object.hasOwn(internals, prop)) {
         internals[prop] = value;
-      } else if (schematype && schematype.virtuals && schematype.virtuals.hasOwnProperty(prop)) {
+      } else if (schematype?.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
         schematype.virtuals[prop].applySetters(value, target);
       } else {
         __array[prop] = value;