mongoose 8.20.2 → 8.20.3

package/lib/schema.js

@@ -1441,17 +1441,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;
@@ -1639,20 +1639,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;
@@ -1689,7 +1689,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.');
@@ -1850,24 +1850,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';
   }
@@ -1897,7 +1897,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];
     }
@@ -1926,7 +1926,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';
   }
@@ -2633,7 +2633,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;
 };
 
 /**
@@ -2781,8 +2781,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;
   }
 
@@ -2795,7 +2795,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);
@@ -3021,7 +3021,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

@@ -47,10 +47,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() :
     [];
 
@@ -63,7 +63,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];
     }
   }
@@ -340,7 +340,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;
@@ -363,7 +363,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);
 };
 
@@ -504,7 +504,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;
   }
 
@@ -543,7 +543,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;
   }
 
@@ -580,7 +580,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;

package/lib/types/objectid.js

@@ -30,7 +30,7 @@ Object.defineProperty(ObjectId.prototype, '_id', {
  * Convenience `valueOf()` to allow comparing ObjectIds using double equals re: gh-7299
  */
 
-if (!ObjectId.prototype.hasOwnProperty('valueOf')) {
+if (!Object.hasOwn(ObjectId.prototype, 'valueOf')) {
   ObjectId.prototype.valueOf = function objectIdValueOf() {
     return this.toString();
   };

package/lib/utils.js

@@ -708,18 +708,6 @@ exports.object.vals = function vals(o) {
   return ret;
 };
 
-const hop = Object.prototype.hasOwnProperty;
-
-/**
- * Safer helper for hasOwnProperty checks
- *
- * @param {Object} obj
- * @param {String} prop
- */
-
-exports.object.hasOwnProperty = function(obj, prop) {
-  return hop.call(obj, prop);
-};
 
 /**
  * Determine if `val` is null or undefined
@@ -770,8 +758,6 @@ exports.array.flatten = function flatten(arr, filter, ret) {
  * ignore
  */
 
-const _hasOwnProperty = Object.prototype.hasOwnProperty;
-
 exports.hasUserDefinedProperty = function(obj, key) {
   if (obj == null) {
     return false;
@@ -786,7 +772,7 @@ exports.hasUserDefinedProperty = function(obj, key) {
     return false;
   }
 
-  if (_hasOwnProperty.call(obj, key)) {
+  if (Object.hasOwn(obj, key)) {
     return true;
   }
   if (typeof obj === 'object' && key in obj) {

package/lib/virtualType.js

@@ -143,7 +143,7 @@ VirtualType.prototype.set = function(fn) {
 VirtualType.prototype.applyGetters = function(value, doc) {
   if (utils.hasUserDefinedProperty(this.options, ['ref', 'refPath']) &&
       doc.$$populatedVirtuals &&
-      doc.$$populatedVirtuals.hasOwnProperty(this.path)) {
+      Object.hasOwn(doc.$$populatedVirtuals, this.path)) {
     value = doc.$$populatedVirtuals[this.path];
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.20.2",
+  "version": "8.20.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -114,6 +114,7 @@
     "tdd": "mocha ./test/*.test.js --inspect --watch --recursive --watch-files ./**/*.{js,ts}",
     "test-coverage": "nyc --reporter=html --reporter=text npm test",
     "ts-benchmark": "cd ./benchmarks/typescript/simple && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check",
+    "ts-benchmark:local": "node ./scripts/create-tarball && cd ./benchmarks/typescript/simple && rm -rf ./node_modules && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check",
     "attest-benchmark": "node ./benchmarks/typescript/infer.bench.mts"
   },
   "main": "./index.js",

package/types/index.d.ts

@@ -542,8 +542,7 @@ declare module 'mongoose' {
 
     /** Adds static "class" methods to Models compiled from this schema. */
     static<K extends keyof TStaticMethods>(name: K, fn: TStaticMethods[K]): this;
-    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] }): this;
-    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: TModelType, ...args: any[]) => any }): this;
+    static(obj: Partial<TStaticMethods> & { [name: string]: (this: TModelType, ...args: any[]) => any }): this;
     static(name: string, fn: (this: TModelType, ...args: any[]) => any): this;
 
     /** Object of currently defined statics on this schema. */

package/types/inferrawdoctype.d.ts

@@ -97,7 +97,7 @@ declare module 'mongoose' {
       ResolveRawPathType<Options['of'] extends ReadonlyArray<infer Item> ? Item : never>
     : PathValueType extends ArrayConstructor ? any[]
     : PathValueType extends typeof Schema.Types.Mixed ? any
-    : IfEquals<PathValueType, ObjectConstructor> extends true ? any
+    : PathValueType extends ObjectConstructor ? any
     : IfEquals<PathValueType, {}> extends true ? any
     : PathValueType extends typeof SchemaType ? PathValueType['prototype']
     : PathValueType extends Record<string, any> ? InferRawDocType<PathValueType>

package/types/inferschematype.d.ts

@@ -127,11 +127,6 @@ declare module 'mongoose' {
     : T;
 }
 
-type IsPathDefaultUndefined<PathType> =
-  PathType extends { default: undefined } ? true
-  : PathType extends { default: (...args: any[]) => undefined } ? true
-  : false;
-
 type RequiredPropertyDefinition =
   | {
       required: true | string | [true, string | undefined] | { isRequired: true };
@@ -150,16 +145,17 @@ type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
     P extends { required: false } ?
       false
     : true
-  : P extends Record<TypeKey, ArrayConstructor | any[]> ?
-    IsPathDefaultUndefined<P> extends true ?
-      false
-    : true
-  : P extends Record<TypeKey, any> ?
-    P extends { default: any } ?
-      IfEquals<P['default'], undefined, false, true>
-    : false
+  : P extends { default: undefined | null | ((...args: any[]) => undefined) | ((...args: any[]) => null) } ? false
+  : P extends { default: any } ? true
+  : P extends Record<TypeKey, ArrayConstructor | any[]> ? true
   : false;
 
+// Internal type used to efficiently check for never or any types
+// can be efficiently checked like:
+// `[T] extends [neverOrAny] ? T : ...`
+// to avoid edge cases
+type neverOrAny = ' ~neverOrAny~';
+
 /**
  * @summary A Utility to obtain schema's required path keys.
  * @param {T} T A generic refers to document definition.
@@ -238,6 +234,7 @@ type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> =
 
 type IsSchemaTypeFromBuiltinClass<T> =
   T extends typeof String ? true
+  : unknown extends Buffer ? false
   : T extends typeof Number ? true
   : T extends typeof Boolean ? true
   : T extends typeof Buffer ? true
@@ -254,7 +251,6 @@ type IsSchemaTypeFromBuiltinClass<T> =
   : T extends Types.Decimal128 ? true
   : T extends NativeDate ? true
   : T extends typeof Schema.Types.Mixed ? true
-  : unknown extends Buffer ? false
   : T extends Buffer ? true
   : false;
 
@@ -270,12 +266,10 @@ type ResolvePathType<
   Options extends SchemaTypeOptions<PathValueType> = {},
   TypeKey extends string = DefaultSchemaOptions['typeKey'],
   TypeHint = never
-> = IfEquals<
-  TypeHint,
-  never,
-  PathValueType extends Schema ? InferSchemaType<PathValueType>
+> = [TypeHint] extends [never]
+  ? PathValueType extends Schema ? InferSchemaType<PathValueType>
   : PathValueType extends AnyArray<infer Item> ?
-    IfEquals<Item, never> extends true
+    [Item] extends [never]
       ? any[]
       : Item extends Schema ?
         // If Item is a schema, infer its type.
@@ -314,7 +308,7 @@ type ResolvePathType<
     : never
   : PathValueType extends ArrayConstructor ? any[]
   : PathValueType extends typeof Schema.Types.Mixed ? any
-  : IfEquals<PathValueType, ObjectConstructor> extends true ? any
+  : PathValueType extends ObjectConstructor ? any
   : IfEquals<PathValueType, {}> extends true ? any
   : PathValueType extends typeof SchemaType ? PathValueType['prototype']
   : PathValueType extends Record<string, any> ?
@@ -325,6 +319,5 @@ type ResolvePathType<
         typeKey: TypeKey;
       }
     >
-  : unknown,
-  TypeHint
->;
+  : unknown
+  : TypeHint;

package/types/virtuals.d.ts

@@ -8,7 +8,7 @@ declare module 'mongoose' {
   type TVirtualPathFN<DocType = {}, PathType = unknown, TInstanceMethods = {}, TReturn = unknown> =
     <T = HydratedDocument<DocType, TInstanceMethods>>(this: Document<any, any, DocType> & DocType, value: PathType, virtual: VirtualType<T>, doc: Document<any, any, DocType> & DocType) => TReturn;
 
-    type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
-      [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
-    };
+  type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
+    [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
+  };
 }