mongoose 8.8.4 → 8.9.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.8.4",
+  "version": "8.9.1",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -19,9 +19,9 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "bson": "^6.7.0",
+    "bson": "^6.10.1",
     "kareem": "2.6.3",
-    "mongodb": "~6.10.0",
+    "mongodb": "~6.12.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",
@@ -30,8 +30,8 @@
   "devDependencies": {
     "@babel/core": "7.26.0",
     "@babel/preset-env": "7.26.0",
-    "@typescript-eslint/eslint-plugin": "^8.4.0",
-    "@typescript-eslint/parser": "^8.4.0",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
     "acquit": "1.3.0",
     "acquit-ignore": "0.2.1",
     "acquit-require": "0.1.1",

package/types/expressions.d.ts

@@ -1150,6 +1150,21 @@ declare module 'mongoose' {
       $first: Expression;
     }
 
+    export interface FirstN {
+      /**
+       * $firstN can be used as an aggregation accumulator or array operator.
+       * As an aggregation accumulator, it returns an aggregation of the first n elements within a group.
+       * As an array operator, it returns the specified number of elements from the beginning of an array.
+       *
+       * @version 5.2
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/firstN/#mongodb-expression-exp.-first
+       */
+      $firstN: {
+        input: Expression
+        n: Expression,
+      };
+    }
+
     export interface In {
       /**
        * Returns a boolean indicating whether a specified value is in an array.
@@ -1190,6 +1205,21 @@ declare module 'mongoose' {
       $last: Expression;
     }
 
+    export interface LastN {
+      /**
+       * $lastN can be used as an aggregation accumulator or array operator.
+       * As an aggregation accumulator, it an aggregation of the last n elements within a group.
+       * As an array operator, it returns the specified number of elements from the end of an array.
+       *
+       * @version 5.2
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/lastN/#mongodb-group-grp.-lastN
+       */
+      $lastN: {
+        input: Expression
+        n: Expression,
+      };
+    }
+
     export interface LinearFill {
       /**
        * Fills null and missing fields in a window using linear interpolation based on surrounding field values.
@@ -2000,6 +2030,34 @@ declare module 'mongoose' {
       $avg: Expression;
     }
 
+    export interface Bottom {
+      /**
+       * Returns the bottom element within a group according to the specified sort order.
+       *
+       * @version 5.2
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/bottom/#mongodb-group-grp.-bottom
+       */
+      $bottom: {
+        sortBy: AnyObject,
+        output: Expression
+      };
+    }
+
+    export interface BottomN {
+      /**
+       * Returns an aggregation of the bottom n elements within a group, according to the specified sort order.
+       * If the group contains fewer than n elements, $bottomN returns all elements in the group.
+       *
+       * @version 5.2
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/bottomN/#mongodb-group-grp.-bottomN
+       */
+      $bottomN: {
+        n: Expression,
+        sortBy: AnyObject,
+        output: Expression
+      };
+    }
+
     export interface Count {
       /**
        * Returns the number of documents in a group.
@@ -2158,6 +2216,20 @@ declare module 'mongoose' {
       $max: Expression | Expression[];
     }
 
+    export interface MaxN {
+      /**
+       * Returns an aggregation of the maxmimum value n elements within a group.
+       * If the group contains fewer than n elements, $maxN returns all elements in the group.
+       *
+       * @version 5.2
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/maxN/#mongodb-group-grp.-maxN
+       */
+      $maxN: {
+        input: Expression
+        n: Expression,
+      };
+    }
+
     export interface Min {
       /**
        * Returns the minimum value. $min compares both value and type, using the specified BSON comparison order for
@@ -2169,6 +2241,20 @@ declare module 'mongoose' {
       $min: Expression | Expression[];
     }
 
+    export interface MinN {
+      /**
+       * Returns an aggregation of the minimum value n elements within a group.
+       * If the group contains fewer than n elements, $minN returns all elements in the group.
+       *
+       * @version 5.2
+       * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/minN/#mongodb-group-grp.-minN
+       */
+      $minN: {
+        input: Expression
+        n: Expression,
+      };
+    }
+
     export interface Push {
       /**
        * Returns an array of all values that result from applying an expression to documents.
@@ -2605,6 +2691,8 @@ declare module 'mongoose' {
   export type ArrayExpressionOperatorReturningArray =
     Expression.ConcatArrays |
     Expression.Filter |
+    Expression.FirstN |
+    Expression.LastN |
     Expression.Map |
     Expression.ObjectToArray |
     Expression.Range |
@@ -2763,12 +2851,16 @@ declare module 'mongoose' {
     Expression.DocumentNumber |
     Expression.ExpMovingAvg |
     Expression.First |
+    Expression.FirstN |
     Expression.Integral |
     Expression.Last |
+    Expression.LastN |
     Expression.LinearFill |
     Expression.Locf |
     Expression.Max |
+    Expression.MaxN |
     Expression.Min |
+    Expression.MinN |
     Expression.Push |
     Expression.Rank |
     Expression.Shift |
@@ -2783,6 +2875,10 @@ declare module 'mongoose' {
 
   export type WindowOperatorReturningArray =
     Expression.AddToSet |
+    Expression.FirstN |
+    Expression.LastN |
+    Expression.MaxN |
+    Expression.MinN |
     Expression.Push;
 
   export type WindowOperatorReturningNumber =
@@ -2858,12 +2954,18 @@ declare module 'mongoose' {
     Expression.Accumulator |
     Expression.AddToSet |
     Expression.Avg |
+    Expression.Bottom |
+    Expression.BottomN |
     Expression.Count |
     Expression.First |
+    Expression.FirstN |
     Expression.Last |
+    Expression.LastN |
     Expression.Max |
+    Expression.MaxN |
     Expression.MergeObjects |
     Expression.Min |
+    Expression.MinN |
     Expression.Push |
     Expression.StdDevPop |
     Expression.StdDevSamp |

package/types/index.d.ts

@@ -309,7 +309,7 @@ declare module 'mongoose' {
     eachPath(fn: (path: string, type: SchemaType) => void): this;
 
     /** Defines an index (most likely compound) for this schema. */
-    index(fields: IndexDefinition, options?: IndexOptions): this;
+    index(fields: IndexDefinition, options?: Omit<IndexOptions, 'unique'> & { unique?: boolean | [true, string] }): this;
 
     /**
      * Define a search index for this schema.

package/types/indexes.d.ts

@@ -63,7 +63,7 @@ declare module 'mongoose' {
   type ConnectionSyncIndexesResult = Record<string, OneCollectionSyncIndexesResult>;
   type OneCollectionSyncIndexesResult = Array<string> & mongodb.MongoServerError;
 
-  interface IndexOptions extends mongodb.CreateIndexesOptions {
+  type IndexOptions = Omit<mongodb.CreateIndexesOptions, 'expires' | 'weights' | 'unique'> & {
     /**
      * `expires` utilizes the `ms` module from [guille](https://github.com/guille/) allowing us to use a friendlier syntax:
      *
@@ -86,7 +86,9 @@ declare module 'mongoose' {
      */
     expires?: number | string;
     weights?: Record<string, number>;
-  }
+
+    unique?: boolean | [true, string]
+  };
 
   type SearchIndexDescription = mongodb.SearchIndexDescription;
 }

package/types/inferschematype.d.ts

@@ -219,27 +219,29 @@ type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
             ? true
             : T extends (typeof Schema.Types.Decimal128)
               ? true
-              : T extends (typeof Schema.Types.String)
+              : T extends (typeof Schema.Types.Int32)
                 ? true
-                : T extends (typeof Schema.Types.Number)
-                  ? true
-                  : T extends (typeof Schema.Types.Date)
+                  : T extends (typeof Schema.Types.String)
                     ? true
-                    : T extends (typeof Schema.Types.Boolean)
+                    : T extends (typeof Schema.Types.Number)
                       ? true
-                      : T extends (typeof Schema.Types.Buffer)
+                      : T extends (typeof Schema.Types.Date)
                         ? true
-                        : T extends Types.ObjectId
+                        : T extends (typeof Schema.Types.Double)
                           ? true
-                          : T extends Types.Decimal128
+                          : T extends (typeof Schema.Types.Boolean)
                             ? true
-                            : T extends Buffer
+                            : T extends Types.ObjectId
                               ? true
-                              : T extends NativeDate
+                              : T extends Types.Decimal128
                                 ? true
-                                : T extends (typeof Schema.Types.Mixed)
+                                : T extends Buffer
                                   ? true
-                                  : IfEquals<T, Schema.Types.ObjectId, true, false>;
+                                  : T extends NativeDate
+                                    ? true
+                                    : T extends (typeof Schema.Types.Mixed)
+                                      ? true
+                                      : IfEquals<T, Schema.Types.ObjectId, true, false>;
 
 /**
  * @summary Resolve path type by returning the corresponding type.
@@ -302,18 +304,18 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
                                     PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
                                       IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
                                         IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
-                                          IfEquals<PathValueType, Schema.Types.BigInt> extends true ? bigint :
-                                            IfEquals<PathValueType, BigInt> extends true ? bigint :
-                                              PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
-                                                PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
-                                                  IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
-                                                    PathValueType extends MapConstructor | 'Map' ? Map<string, ResolvePathType<Options['of']>> :
-                                                      IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolvePathType<Options['of']>> :
-                                                        PathValueType extends ArrayConstructor ? any[] :
-                                                          PathValueType extends typeof Schema.Types.Mixed ? any:
-                                                            IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                                              IfEquals<PathValueType, {}> extends true ? any:
-                                                                PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                                  PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
-                                                                    unknown,
-    TypeHint>;
+                                            IfEquals<PathValueType, Schema.Types.BigInt> extends true ? bigint :
+                                              IfEquals<PathValueType, BigInt> extends true ? bigint :
+                                                PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
+                                                  PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
+                                                    IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
+                                                      PathValueType extends MapConstructor | 'Map' ? Map<string, ResolvePathType<Options['of']>> :
+                                                        IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolvePathType<Options['of']>> :
+                                                          PathValueType extends ArrayConstructor ? any[] :
+                                                            PathValueType extends typeof Schema.Types.Mixed ? any:
+                                                              IfEquals<PathValueType, ObjectConstructor> extends true ? any:
+                                                                IfEquals<PathValueType, {}> extends true ? any:
+                                                                  PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                                                                    PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
+                                                                      unknown,
+  TypeHint>;

package/types/populate.d.ts

@@ -37,6 +37,8 @@ declare module 'mongoose' {
     localField?: string;
     /** Overwrite the schema-level foreign field to populate on if this is a populated virtual. */
     foreignField?: string;
+    /** Set to `false` to prevent Mongoose from repopulating paths that are already populated */
+    forceRepopulate?: boolean;
   }
 
   interface PopulateOption {

package/types/schematypes.d.ts

@@ -12,6 +12,16 @@ declare module 'mongoose' {
    */
   type Decimal128 = Schema.Types.Decimal128;
 
+
+  /**
+   * The Mongoose Int32 [SchemaType](/docs/schematypes.html). Used for
+   * declaring paths in your schema that should be
+   * 32-bit integers
+   * Do not use this to create a new Int32 instance, use `mongoose.Types.Int32`
+   * instead.
+   */
+  type Int32 = Schema.Types.Int32;
+
   /**
    * The Mongoose Mixed [SchemaType](/docs/schematypes.html). Used for
    * declaring paths in your schema that Mongoose's change tracking, casting,
@@ -25,6 +35,13 @@ declare module 'mongoose' {
    */
   type Number = Schema.Types.Number;
 
+
+  /**
+   * The Mongoose Double [SchemaType](/docs/schematypes.html). Used for
+   * declaring paths in your schema that Mongoose should cast to doubles (IEEE 754-2008)/
+   */
+  type Double = Schema.Types.Double;
+
   /**
    * The Mongoose ObjectId [SchemaType](/docs/schematypes.html). Used for
    * declaring paths in your schema that should be
@@ -111,7 +128,7 @@ declare module 'mongoose' {
      * will build a unique index on this path when the
      * model is compiled. [The `unique` option is **not** a validator](/docs/validation.html#the-unique-option-is-not-a-validator).
      */
-    unique?: boolean | number;
+    unique?: boolean | number | [true, string];
 
     /**
      * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
@@ -387,6 +404,14 @@ declare module 'mongoose' {
         defaultOptions: Record<string, any>;
       }
 
+      class Int32 extends SchemaType {
+        /** This schema type's name, to defend against minifiers that mangle function names. */
+        static schemaName: 'Int32';
+
+        /** Default options for this SchemaType */
+        defaultOptions: Record<string, any>;
+      }
+
       class DocumentArray extends SchemaType implements AcceptsDiscriminator {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: 'DocumentArray';
@@ -439,6 +464,14 @@ declare module 'mongoose' {
         defaultOptions: Record<string, any>;
       }
 
+      class Double extends SchemaType {
+        /** This schema type's name, to defend against minifiers that mangle function names. */
+        static schemaName: 'Double';
+
+        /** Default options for this SchemaType */
+        defaultOptions: Record<string, any>;
+      }
+
       class ObjectId extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: 'ObjectId';

package/types/types.d.ts

@@ -60,19 +60,21 @@ declare module 'mongoose' {
 
     class Decimal128 extends mongodb.Decimal128 { }
 
-    class DocumentArray<T> extends Types.Array<T extends Types.Subdocument ? T : Types.Subdocument<InferId<T>, any, T> & T> {
+    class DocumentArray<T, THydratedDocumentType extends Types.Subdocument<any> = Types.Subdocument<InferId<T>, any, T> & T> extends Types.Array<THydratedDocumentType> {
       /** DocumentArray constructor */
       constructor(values: AnyObject[]);
 
       isMongooseDocumentArray: true;
 
       /** Creates a subdocument casted to this schema. */
-      create(obj: any): T extends Types.Subdocument ? T : Types.Subdocument<InferId<T>> & T;
+      create(obj: any): THydratedDocumentType;
 
       /** Searches array items for the first document with a matching _id. */
-      id(id: any): (T extends Types.Subdocument ? T : Types.Subdocument<InferId<T>> & T) | null;
+      id(id: any): THydratedDocumentType | null;
 
       push(...args: (AnyKeys<T> & AnyObject)[]): number;
+
+      splice(start: number, deleteCount?: number, ...args: (AnyKeys<T> & AnyObject)[]): THydratedDocumentType[];
     }
 
     class Map<V> extends global.Map<string, V> {