mongoose 8.16.3 → 8.16.5

package/lib/connection.js

@@ -1324,8 +1324,10 @@ Connection.prototype.onClose = function onClose(force) {
 
   this.emit('close', force);
 
+  const wasForceClosed = typeof force === 'object' && force !== null ? force.force : force;
+
   for (const db of this.otherDbs) {
-    this._destroyCalled ? db.destroy({ force: force, skipCloseClient: true }) : db.close({ force: force, skipCloseClient: true });
+    this._destroyCalled ? db.destroy({ force: wasForceClosed, skipCloseClient: true }) : db.close({ force: wasForceClosed, skipCloseClient: true });
   }
 };
 

package/lib/document.js

@@ -2703,6 +2703,10 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip, isNestedValidate
     if (!doc.$__isSelected(path) && !doc.$isModified(path)) {
       return false;
     }
+    if (path.endsWith('.$*')) {
+      // Skip $* paths - they represent map schemas, not actual document paths
+      return false;
+    }
     if (doc.$__.cachedRequired != null && path in doc.$__.cachedRequired) {
       return doc.$__.cachedRequired[path];
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.16.3",
+  "version": "8.16.5",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/connection.d.ts

@@ -72,11 +72,15 @@ declare module 'mongoose' {
   }[keyof SchemaMap];
 
   class Connection extends events.EventEmitter implements SessionStarter {
+    /** Runs a [db-level aggregate()](https://www.mongodb.com/docs/manual/reference/method/db.aggregate/) on this connection's underlying `db` */
     aggregate<ResultType = unknown>(pipeline?: PipelineStage[] | null, options?: AggregateOptions): Aggregate<Array<ResultType>>;
 
     /** Returns a promise that resolves when this connection successfully connects to MongoDB */
     asPromise(): Promise<this>;
 
+    /** The Mongoose instance this connection is associated with */
+    base: Mongoose;
+
     bulkWrite<TSchemaMap extends Record<string, AnyObject>>(
       ops: Array<ConnectionBulkWriteModel<TSchemaMap>>,
       options: mongodb.ClientBulkWriteOptions & { ordered: false }

package/types/document.d.ts

@@ -45,8 +45,8 @@ declare module 'mongoose' {
     /** Don't run validation on this path or persist changes to this path. */
     $ignore(path: string): void;
 
-    /** Checks if a path is set to its default. */
-    $isDefault(path: string): boolean;
+    /** Checks if a path is set to its default. If no path set, checks if any path is set to its default. */
+    $isDefault(path?: string): boolean;
 
     /** Getter/setter, determines whether the document was removed or not. */
     $isDeleted(val?: boolean): boolean;

package/types/index.d.ts

@@ -83,17 +83,17 @@ declare module 'mongoose' {
     collection?: string,
     options?: CompileModelOptions
   ): Model<
-  InferSchemaType<TSchema>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
-  ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
-  HydratedDocument<
-  InferSchemaType<TSchema>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'> & ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'>
-  >,
-  TSchema
+    InferSchemaType<TSchema>,
+    ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+    ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
+    ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
+    HydratedDocument<
+      InferSchemaType<TSchema>,
+      ObtainSchemaGeneric<TSchema, 'TVirtuals'> & ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
+      ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+      ObtainSchemaGeneric<TSchema, 'TVirtuals'>
+    >,
+    TSchema
   > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
 
   export function model<T>(name: string, schema?: Schema<T, any, any> | Schema<T & Document, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
@@ -278,7 +278,23 @@ declare module 'mongoose' {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType, THydratedDocumentType> | DocType, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
+    constructor(
+      definition?: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType, THydratedDocumentType> | DocType,
+      options?: SchemaOptions<
+        FlatRecord<DocType>,
+        TInstanceMethods,
+        TQueryHelpers,
+        TStaticMethods,
+        TVirtuals,
+        THydratedDocumentType,
+        IfEquals<
+          TModelType,
+          Model<any, any, any, any>,
+          Model<DocType, TQueryHelpers, TInstanceMethods, TVirtuals, THydratedDocumentType>,
+          TModelType
+        >
+      > | ResolveSchemaOptions<TSchemaOptions>
+    );
 
     /** Adds key path / schema type pairs to this schema. */
     add(obj: SchemaDefinition<SchemaDefinitionType<RawDocType>, RawDocType> | Schema, prefix?: string): this;

package/types/inferschematype.d.ts

@@ -56,8 +56,8 @@ declare module 'mongoose' {
    * @param {TSchema} TSchema A generic of schema type instance.
    * @param {alias} alias Targeted generic alias.
    */
-  type ObtainSchemaGeneric<TSchema, alias extends 'EnforcedDocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'TVirtuals' | 'TStaticMethods' | 'TSchemaOptions' | 'DocType'> =
-   TSchema extends Schema<infer EnforcedDocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer TVirtuals, infer TStaticMethods, infer TSchemaOptions, infer DocType>
+  type ObtainSchemaGeneric<TSchema, alias extends 'EnforcedDocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'TVirtuals' | 'TStaticMethods' | 'TSchemaOptions' | 'DocType' | 'THydratedDocumentType'> =
+   TSchema extends Schema<infer EnforcedDocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer TVirtuals, infer TStaticMethods, infer TSchemaOptions, infer DocType, infer THydratedDocumentType>
      ? {
        EnforcedDocType: EnforcedDocType;
        M: M;
@@ -67,6 +67,7 @@ declare module 'mongoose' {
        TStaticMethods: TStaticMethods;
        TSchemaOptions: TSchemaOptions;
        DocType: DocType;
+       THydratedDocumentType: THydratedDocumentType;
      }[alias]
      : unknown;
 
@@ -107,7 +108,7 @@ type IsPathDefaultUndefined<PathType> = PathType extends { default: undefined }
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  */
 type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
-  P extends { required: true | [true, string | undefined] | { isRequired: true } } | ArrayConstructor | any[]
+  P extends { required: true | string | [true, string | undefined] | { isRequired: true } } | ArrayConstructor | any[]
     ? true
     : P extends { required: boolean }
       ? P extends { required: false }
@@ -203,7 +204,7 @@ TypeHint<PathValueType>
  * @param {T} T A generic refers to string path enums.
  * @returns Path enum values type as literal strings or string.
  */
-type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends ReadonlyArray<infer E> ? E : T extends { values: any } ? PathEnumOrString<T['values']> : string;
+type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends ReadonlyArray<infer E> ? E : T extends { values: any } ? PathEnumOrString<T['values']> : T extends Record<string, infer V> ? V : string;
 
 type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
   ? true

package/types/models.d.ts

@@ -23,7 +23,14 @@ declare module 'mongoose' {
     ): U;
   }
 
-  interface MongooseBulkWriteOptions extends mongodb.BulkWriteOptions {
+  export type MongooseBulkWriteResult = mongodb.BulkWriteResult & {
+    mongoose?: {
+      validationErrors: Error[],
+      results: Array<Error | mongodb.WriteError | null>
+    }
+  };
+
+  export interface MongooseBulkWriteOptions extends mongodb.BulkWriteOptions {
     session?: ClientSession;
     skipValidation?: boolean;
     throwOnValidationError?: boolean;
@@ -308,18 +315,18 @@ declare module 'mongoose' {
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options: MongooseBulkWriteOptions & { ordered: false }
-    ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[], results: Array<Error | mongodb.WriteError | null> } }>;
+    ): Promise<MongooseBulkWriteResult>;
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options?: MongooseBulkWriteOptions
-    ): Promise<mongodb.BulkWriteResult>;
+    ): Promise<MongooseBulkWriteResult>;
 
     /**
      * Sends multiple `save()` calls in a single `bulkWrite()`. This is faster than
      * sending multiple `save()` calls because with `bulkSave()` there is only one
      * network round trip to the MongoDB server.
      */
-    bulkSave(documents: Array<Document>, options?: MongooseBulkSaveOptions): Promise<mongodb.BulkWriteResult>;
+    bulkSave(documents: Array<Document>, options?: MongooseBulkSaveOptions): Promise<MongooseBulkWriteResult>;
 
     /** Collection the model uses. */
     collection: Collection;

package/types/schemaoptions.d.ts

@@ -16,7 +16,8 @@ declare module 'mongoose' {
     QueryHelpers = {},
     TStaticMethods = {},
     TVirtuals = {},
-    THydratedDocumentType = HydratedDocument<DocType, TInstanceMethods, QueryHelpers>
+    THydratedDocumentType = HydratedDocument<DocType, TInstanceMethods, QueryHelpers>,
+    TModelType = Model<DocType, QueryHelpers, TInstanceMethods, TVirtuals, THydratedDocumentType>
   > {
     /**
      * By default, Mongoose's init() function creates all the indexes defined in your model's schema by
@@ -219,8 +220,8 @@ declare module 'mongoose' {
     statics?: IfEquals<
       TStaticMethods,
       {},
-      { [name: string]: (this: Model<DocType>, ...args: any[]) => unknown },
-      AddThisParameter<TStaticMethods, Model<DocType>>
+      { [name: string]: (this: TModelType, ...args: any[]) => unknown },
+      AddThisParameter<TStaticMethods, TModelType>
     >
 
     /**