mongoose 8.8.3 → 8.9.0

package/lib/schema/int32.js

@@ -0,0 +1,249 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const CastError = require('../error/cast');
+const SchemaType = require('../schemaType');
+const castInt32 = require('../cast/int32');
+
+/**
+ * Int32 SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api public
+ */
+
+function SchemaInt32(path, options) {
+  SchemaType.call(this, path, options, 'Int32');
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+SchemaInt32.schemaName = 'Int32';
+
+SchemaInt32.defaultOptions = {};
+
+/*!
+ * Inherits from SchemaType.
+ */
+SchemaInt32.prototype = Object.create(SchemaType.prototype);
+SchemaInt32.prototype.constructor = SchemaInt32;
+
+/*!
+ * ignore
+ */
+
+SchemaInt32._cast = castInt32;
+
+/**
+ * Sets a default option for all Int32 instances.
+ *
+ * #### Example:
+ *
+ *     // Make all Int32 fields required by default
+ *     mongoose.Schema.Int32.set('required', true);
+ *
+ * @param {String} option The option you'd like to set the value for
+ * @param {Any} value value for option
+ * @return {undefined}
+ * @function set
+ * @static
+ * @api public
+ */
+
+SchemaInt32.set = SchemaType.set;
+
+SchemaInt32.setters = [];
+
+/**
+ * Attaches a getter for all Int32 instances
+ *
+ * #### Example:
+ *
+ *     // Converts int32 to be a represent milliseconds upon access
+ *     mongoose.Schema.Int32.get(v => v == null ? '0 ms' : v.toString() + ' ms');
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaInt32.get = SchemaType.get;
+
+/*!
+ * ignore
+ */
+
+SchemaInt32._defaultCaster = v => {
+  const INT32_MAX = 0x7FFFFFFF;
+  const INT32_MIN = -0x80000000;
+
+  if (v != null) {
+    if (typeof v !== 'number' || v !== (v | 0) || v < INT32_MIN || v > INT32_MAX) {
+      throw new Error();
+    }
+  }
+
+  return v;
+};
+
+/**
+ * Get/set the function used to cast arbitrary values to 32-bit integers
+ *
+ * #### Example:
+ *
+ *     // Make Mongoose cast NaN to 0
+ *     const defaultCast = mongoose.Schema.Types.Int32.cast();
+ *     mongoose.Schema.Types.Int32.cast(v => {
+ *       if (isNaN(v)) {
+ *         return 0;
+ *       }
+ *       return defaultCast(v);
+ *     });
+ *
+ *     // Or disable casting for Int32s entirely (only JS numbers within 32-bit integer bounds and null-ish values are permitted)
+ *     mongoose.Schema.Int32.cast(false);
+ *
+ *
+ * @param {Function} caster
+ * @return {Function}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaInt32.cast = function cast(caster) {
+  if (arguments.length === 0) {
+    return this._cast;
+  }
+  if (caster === false) {
+    caster = this._defaultCaster;
+  }
+
+  this._cast = caster;
+
+  return this._cast;
+};
+
+
+/*!
+ * ignore
+ */
+
+SchemaInt32._checkRequired = v => v != null;
+/**
+ * Override the function the required validator uses to check whether a value
+ * passes the `required` check.
+ *
+ * @param {Function} fn
+ * @return {Function}
+ * @function checkRequired
+ * @static
+ * @api public
+ */
+
+SchemaInt32.checkRequired = SchemaType.checkRequired;
+
+/**
+ * Check if the given value satisfies a required validator.
+ *
+ * @param {Any} value
+ * @return {Boolean}
+ * @api public
+ */
+
+SchemaInt32.prototype.checkRequired = function(value) {
+  return this.constructor._checkRequired(value);
+};
+
+/**
+ * Casts to Int32
+ *
+ * @param {Object} value
+ * @param {Object} model this value is optional
+ * @api private
+ */
+
+SchemaInt32.prototype.cast = function(value) {
+  let castInt32;
+  if (typeof this._castFunction === 'function') {
+    castInt32 = this._castFunction;
+  } else if (typeof this.constructor.cast === 'function') {
+    castInt32 = this.constructor.cast();
+  } else {
+    castInt32 = SchemaInt32.cast();
+  }
+
+  try {
+    return castInt32(value);
+  } catch (error) {
+    throw new CastError('Int32', value, this.path, error, this);
+  }
+};
+
+/*!
+ * ignore
+ */
+
+SchemaInt32.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
+
+/*!
+ * ignore
+ */
+
+function handleSingle(val, context) {
+  return this.castForQuery(null, val, context);
+}
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} val
+ * @api private
+ */
+
+SchemaInt32.prototype.castForQuery = function($conditional, val, context) {
+  let handler;
+  if ($conditional != null) {
+    handler = SchemaInt32.$conditionalHandlers[$conditional];
+
+    if (handler) {
+      return handler.call(this, val);
+    }
+
+    return this.applySetters(null, val, context);
+  }
+
+  try {
+    return this.applySetters(val, context);
+  } catch (err) {
+    if (err instanceof CastError && err.path === this.path && this.$fullPath != null) {
+      err.path = this.$fullPath;
+    }
+    throw err;
+  }
+};
+
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaInt32;

package/lib/schema.js

@@ -2810,6 +2810,39 @@ Schema.prototype._getPathType = function(path) {
   return search(path.split('.'), _this);
 };
 
+/**
+ * Transforms the duplicate key error by checking for duplicate key error messages by path.
+ * If no duplicate key error messages are found, returns the original error.
+ *
+ * @param {Error} error The error to transform
+ * @returns {Error} The transformed error
+ * @api private
+ */
+
+Schema.prototype._transformDuplicateKeyError = function _transformDuplicateKeyError(error) {
+  if (!this._duplicateKeyErrorMessagesByPath) {
+    return error;
+  }
+  if (error.code !== 11000 && error.code !== 11001) {
+    return error;
+  }
+
+  if (error.keyPattern != null) {
+    const keyPattern = error.keyPattern;
+    const keys = Object.keys(keyPattern);
+    if (keys.length !== 1) {
+      return error;
+    }
+    const firstKey = keys[0];
+    if (!this._duplicateKeyErrorMessagesByPath.hasOwnProperty(firstKey)) {
+      return error;
+    }
+    return new MongooseError(this._duplicateKeyErrorMessagesByPath[firstKey], { cause: error });
+  }
+
+  return error;
+};
+
 /*!
  * ignore
  */
@@ -2859,6 +2892,8 @@ module.exports = exports = Schema;
  * - [Mixed](https://mongoosejs.com/docs/schematypes.html#mixed)
  * - [UUID](https://mongoosejs.com/docs/schematypes.html#uuid)
  * - [BigInt](https://mongoosejs.com/docs/schematypes.html#bigint)
+ * - [Double] (https://mongoosejs.com/docs/schematypes.html#double)
+ * - [Int32](https://mongoosejs.com/docs/schematypes.html#int32)
  *
  * Using this exposed access to the `Mixed` SchemaType, we can use them in our schema.
  *

package/lib/schemaType.js

@@ -74,7 +74,6 @@ function SchemaType(path, options, instance) {
   this.options = new Options(options);
   this._index = null;
 
-
   if (utils.hasUserDefinedProperty(this.options, 'immutable')) {
     this.$immutable = this.options.immutable;
 
@@ -447,21 +446,38 @@ SchemaType.prototype.index = function(options) {
  *
  * _NOTE: violating the constraint returns an `E11000` error from MongoDB when saving, not a Mongoose validation error._
  *
- * @param {Boolean} bool
+ * You can optionally specify an error message to replace MongoDB's default `E11000 duplicate key error` message.
+ * The following will throw a "Email must be unique" error if `save()`, `updateOne()`, `updateMany()`, `replaceOne()`,
+ * `findOneAndUpdate()`, or `findOneAndReplace()` throws a duplicate key error:
+ *
+ * ```javascript
+ * new Schema({
+ *   email: {
+ *     type: String,
+ *     unique: [true, 'Email must be unique']
+ *   }
+ * });
+ * ```
+ *
+ * Note that the above syntax does **not** work for `bulkWrite()` or `insertMany()`. `bulkWrite()` and `insertMany()`
+ * will still throw MongoDB's default `E11000 duplicate key error` message.
+ *
+ * @param {Boolean} value
+ * @param {String} [message]
  * @return {SchemaType} this
  * @api public
  */
 
-SchemaType.prototype.unique = function(bool) {
+SchemaType.prototype.unique = function unique(value, message) {
   if (this._index === false) {
-    if (!bool) {
+    if (!value) {
       return;
     }
     throw new Error('Path "' + this.path + '" may not have `index` set to ' +
       'false and `unique` set to true');
   }
 
-  if (!this.options.hasOwnProperty('index') && bool === false) {
+  if (!this.options.hasOwnProperty('index') && value === false) {
     return this;
   }
 
@@ -471,7 +487,10 @@ SchemaType.prototype.unique = function(bool) {
     this._index = { type: this._index };
   }
 
-  this._index.unique = bool;
+  this._index.unique = !!value;
+  if (typeof message === 'string') {
+    this._duplicateKeyErrorMessage = message;
+  }
   return this;
 };
 
@@ -1567,8 +1586,9 @@ SchemaType.prototype._castRef = function _castRef(value, doc, init) {
     !doc.$__.populated[path].options ||
     !doc.$__.populated[path].options.options ||
     !doc.$__.populated[path].options.options.lean) {
-    ret = new pop.options[populateModelSymbol](value);
-    ret.$__.wasPopulated = { value: ret._doc._id };
+    const PopulatedModel = pop ? pop.options[populateModelSymbol] : doc.constructor.db.model(this.options.ref);
+    ret = new PopulatedModel(value);
+    ret.$__.wasPopulated = { value: ret._doc._id, options: { [populateModelSymbol]: PopulatedModel } };
   }
 
   return ret;
@@ -1743,6 +1763,14 @@ SchemaType.prototype.getEmbeddedSchemaType = function getEmbeddedSchemaType() {
   return this.$embeddedSchemaType;
 };
 
+/*!
+ * If _duplicateKeyErrorMessage is a string, replace unique index errors "E11000 duplicate key error" with this string.
+ *
+ * @api private
+ */
+
+SchemaType.prototype._duplicateKeyErrorMessage = null;
+
 /*!
  * Module exports.
  */

package/lib/validOptions.js

@@ -17,6 +17,7 @@ const VALID_OPTIONS = Object.freeze([
   'cloneSchemas',
   'createInitialConnection',
   'debug',
+  'forceRepopulate',
   'id',
   'timestamps.createdAt.immutable',
   'maxTimeMS',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.8.3",
+  "version": "8.9.0",
   "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",
@@ -52,8 +52,8 @@
     "highlight.js": "11.10.0",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "markdownlint-cli2": "^0.14.0",
-    "marked": "14.1.3",
+    "markdownlint-cli2": "^0.15.0",
+    "marked": "15.0.3",
     "mkdirp": "^3.0.1",
     "mocha": "10.8.2",
     "moment": "2.30.1",
@@ -65,8 +65,8 @@
     "sinon": "19.0.2",
     "stream-browserify": "3.0.0",
     "tsd": "0.31.2",
-    "typescript": "5.6.3",
-    "uuid": "11.0.2",
+    "typescript": "5.7.2",
+    "uuid": "11.0.3",
     "webpack": "5.96.1"
   },
   "directories": {

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;
 }