mongoose 8.8.4 → 8.9.1

package/lib/schema/double.js

@@ -0,0 +1,212 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const CastError = require('../error/cast');
+const SchemaType = require('../schemaType');
+const castDouble = require('../cast/double');
+
+/**
+ * Double SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api public
+ */
+
+function SchemaDouble(path, options) {
+  SchemaType.call(this, path, options, 'Double');
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+SchemaDouble.schemaName = 'Double';
+
+SchemaDouble.defaultOptions = {};
+
+/*!
+ * Inherits from SchemaType.
+ */
+SchemaDouble.prototype = Object.create(SchemaType.prototype);
+SchemaDouble.prototype.constructor = SchemaDouble;
+
+/*!
+ * ignore
+ */
+
+SchemaDouble._cast = castDouble;
+
+/**
+ * Sets a default option for all Double instances.
+ *
+ * #### Example:
+ *
+ *     // Make all Double fields required by default
+ *     mongoose.Schema.Double.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
+ */
+
+SchemaDouble.set = SchemaType.set;
+
+SchemaDouble.setters = [];
+
+/**
+ * Attaches a getter for all Double instances
+ *
+ * #### Example:
+ *
+ *     // Converts Double to be a represent milliseconds upon access
+ *     mongoose.Schema.Double.get(v => v == null ? '0.000 ms' : v.toString() + ' ms');
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaDouble.get = SchemaType.get;
+
+/*!
+ * ignore
+ */
+
+SchemaDouble._defaultCaster = v => {
+  if (v != null) {
+    if (v._bsontype !== 'Double') {
+      throw new Error();
+    }
+  }
+
+  return v;
+};
+
+/**
+ * Get/set the function used to cast arbitrary values to  IEEE 754-2008 floating points
+ *
+ * #### Example:
+ *
+ *     // Make Mongoose cast any NaNs to 0
+ *     const defaultCast = mongoose.Schema.Types.Double.cast();
+ *     mongoose.Schema.Types.Double.cast(v => {
+ *       if (isNaN(v)) {
+ *         return 0;
+ *       }
+ *       return defaultCast(v);
+ *     });
+ *
+ *     // Or disable casting for Doubles entirely (only JS numbers are permitted)
+ *     mongoose.Schema.Double.cast(false);
+ *
+ *
+ * @param {Function} caster
+ * @return {Function}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaDouble.cast = function cast(caster) {
+  if (arguments.length === 0) {
+    return this._cast;
+  }
+  if (caster === false) {
+    caster = this._defaultCaster;
+  }
+
+  this._cast = caster;
+
+  return this._cast;
+};
+
+
+/*!
+ * ignore
+ */
+
+SchemaDouble._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
+ */
+
+SchemaDouble.checkRequired = SchemaType.checkRequired;
+
+/**
+ * Check if the given value satisfies a required validator.
+ *
+ * @param {Any} value
+ * @return {Boolean}
+ * @api public
+ */
+
+SchemaDouble.prototype.checkRequired = function(value) {
+  return this.constructor._checkRequired(value);
+};
+
+/**
+ * Casts to Double
+ *
+ * @param {Object} value
+ * @param {Object} model this value is optional
+ * @api private
+ */
+
+SchemaDouble.prototype.cast = function(value) {
+  let castDouble;
+  if (typeof this._castFunction === 'function') {
+    castDouble = this._castFunction;
+  } else if (typeof this.constructor.cast === 'function') {
+    castDouble = this.constructor.cast();
+  } else {
+    castDouble = SchemaDouble.cast();
+  }
+
+  try {
+    return castDouble(value);
+  } catch (error) {
+    throw new CastError('Double', value, this.path, error, this);
+  }
+};
+
+/*!
+ * ignore
+ */
+
+function handleSingle(val) {
+  return this.cast(val);
+}
+
+SchemaDouble.prototype.$conditionalHandlers = {
+  ...SchemaType.prototype.$conditionalHandlers,
+  $gt: handleSingle,
+  $gte: handleSingle,
+  $lt: handleSingle,
+  $lte: handleSingle
+};
+
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaDouble;

package/lib/schema/index.js

@@ -19,6 +19,8 @@ exports.ObjectId = require('./objectId');
 exports.String = require('./string');
 exports.Subdocument = require('./subdocument');
 exports.UUID = require('./uuid');
+exports.Double = require('./double');
+exports.Int32 = require('./int32');
 
 // alias
 

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/string.js

@@ -181,11 +181,11 @@ SchemaString.checkRequired = SchemaType.checkRequired;
  *     const s = new Schema({ state: { type: String, enum: states }})
  *     const M = db.model('M', s)
  *     const m = new M({ state: 'invalid' })
- *     m.save(function (err) {
- *       console.error(String(err)) // ValidationError: `invalid` is not a valid enum value for path `state`.
- *       m.state = 'open'
- *       m.save(callback) // success
- *     })
+ *     await m.save()
+ *       .catch((err) => console.error(err)); // ValidationError: `invalid` is not a valid enum value for path `state`.
+ *     m.state = 'open';
+ *     await m.save();
+ *     // success
  *
  *     // or with custom error messages
  *     const enum = {
@@ -195,11 +195,11 @@ SchemaString.checkRequired = SchemaType.checkRequired;
  *     const s = new Schema({ state: { type: String, enum: enum })
  *     const M = db.model('M', s)
  *     const m = new M({ state: 'invalid' })
- *     m.save(function (err) {
- *       console.error(String(err)) // ValidationError: enum validator failed for path `state` with value `invalid`
- *       m.state = 'open'
- *       m.save(callback) // success
- *     })
+ *     await m.save()
+ *       .catch((err) => console.error(err)); // ValidationError: enum validator failed for path `state` with value `invalid`
+ *     m.state = 'open';
+ *     await m.save();
+ *     // success
  *
  * @param {...String|Object} [args] enumeration values
  * @return {SchemaType} this

package/lib/schema.js

@@ -441,7 +441,7 @@ Schema.prototype._clone = function _clone(Constructor) {
       }
     }
   }
-  s.childSchemas = gatherChildSchemas(s);
+  s._gatherChildSchemas();
 
   s.virtuals = clone(this.virtuals);
   s.$globalPluginsApplied = this.$globalPluginsApplied;
@@ -1238,20 +1238,32 @@ Schema.prototype.path = function(path, obj) {
  * ignore
  */
 
-function gatherChildSchemas(schema) {
+Schema.prototype._gatherChildSchemas = function _gatherChildSchemas() {
   const childSchemas = [];
 
-  for (const path of Object.keys(schema.paths)) {
-    const schematype = schema.paths[path];
+  for (const path of Object.keys(this.paths)) {
+    if (typeof path !== 'string') {
+      continue;
+    }
+    const schematype = this.paths[path];
     if (schematype.$isMongooseDocumentArray || schematype.$isSingleNested) {
-      childSchemas.push({ schema: schematype.schema, model: schematype.caster, path: path });
+      childSchemas.push({
+        schema: schematype.schema,
+        model: schematype.caster,
+        path: path
+      });
     } else if (schematype.$isSchemaMap && schematype.$__schemaType.$isSingleNested) {
-      childSchemas.push({ schema: schematype.$__schemaType.schema, model: schematype.$__schemaType.caster, path: path });
+      childSchemas.push({
+        schema: schematype.$__schemaType.schema,
+        model: schematype.$__schemaType.caster,
+        path: path
+      });
     }
   }
 
+  this.childSchemas = childSchemas;
   return childSchemas;
-}
+};
 
 /*!
  * ignore
@@ -2134,6 +2146,12 @@ Schema.prototype.index = function(fields, options) {
     }
   }
 
+  for (const existingIndex of this.indexes()) {
+    if (util.isDeepStrictEqual(existingIndex[0], fields)) {
+      throw new MongooseError(`Schema already has an index on ${JSON.stringify(fields)}`);
+    }
+  }
+
   this._indexes.push([fields, options]);
   return this;
 };
@@ -2810,6 +2828,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 +2910,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',