mongoose 8.8.3 → 8.9.0

package/lib/model.js

@@ -436,6 +436,7 @@ Model.prototype.$__handleSave = function(options, callback) {
 Model.prototype.$__save = function(options, callback) {
   this.$__handleSave(options, (error, result) => {
     if (error) {
+      error = this.$__schema._transformDuplicateKeyError(error);
       const hooks = this.$__schema.s.hooks;
       return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
         callback(error, this);
@@ -3356,7 +3357,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     let error;
     [res, error] = await this.$__collection.bulkWrite(validOps, options).
       then(res => ([res, null])).
-      catch(err => ([null, err]));
+      catch(error => ([null, error]));
 
     if (error) {
       if (validationErrors.length > 0) {
@@ -4199,6 +4200,7 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
  * - options: optional query options like sort, limit, etc
  * - justOne: optional boolean, if true Mongoose will always set `path` to a document, or `null` if no document was found. If false, Mongoose will always set `path` to an array, which will be empty if no documents are found. Inferred from schema by default.
  * - strictPopulate: optional boolean, set to `false` to allow populating paths that aren't in the schema.
+ * - forceRepopulate: optional boolean, defaults to `true`. Set to `false` to prevent Mongoose from repopulating paths that are already populated
  *
  * #### Example:
  *
@@ -4235,6 +4237,7 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
  * @param {Boolean} [options.strictPopulate=true] Set to false to allow populating paths that aren't defined in the given model's schema.
  * @param {Object} [options.options=null] Additional options like `limit` and `lean`.
  * @param {Function} [options.transform=null] Function that Mongoose will call on every populated document that allows you to transform the populated document.
+ * @param {Boolean} [options.forceRepopulate=true] Set to `false` to prevent Mongoose from repopulating paths that are already populated
  * @param {Function} [callback(err,doc)] Optional callback, executed upon completion. Receives `err` and the `doc(s)`.
  * @return {Promise}
  * @api public
@@ -4245,67 +4248,34 @@ Model.populate = async function populate(docs, paths) {
   if (typeof paths === 'function' || typeof arguments[2] === 'function') {
     throw new MongooseError('Model.populate() no longer accepts a callback');
   }
-  const _this = this;
   // normalized paths
   paths = utils.populate(paths);
-  // data that should persist across subPopulate calls
-  const cache = {};
-
-  return new Promise((resolve, reject) => {
-    _populate(_this, docs, paths, cache, (err, res) => {
-      if (err) {
-        return reject(err);
-      }
-      resolve(res);
-    });
-  });
-};
-
-/**
- * Populate helper
- *
- * @param {Model} model the model to use
- * @param {Document|Array} docs Either a single document or array of documents to populate.
- * @param {Object} paths
- * @param {never} cache Unused
- * @param {Function} [callback] Optional callback, executed upon completion. Receives `err` and the `doc(s)`.
- * @return {Function}
- * @api private
- */
 
-function _populate(model, docs, paths, cache, callback) {
-  let pending = paths.length;
   if (paths.length === 0) {
-    return callback(null, docs);
+    return docs;
   }
+
   // each path has its own query options and must be executed separately
+  const promises = [];
   for (const path of paths) {
-    populate(model, docs, path, next);
+    promises.push(_populatePath(this, docs, path));
   }
+  await Promise.all(promises);
 
-  function next(err) {
-    if (err) {
-      return callback(err, null);
-    }
-    if (--pending) {
-      return;
-    }
-    callback(null, docs);
-  }
-}
+  return docs;
+};
 
 /*!
- * Populates `docs`
+ * Populates `docs` for a single `populateOptions` instance.
  */
 const excludeIdReg = /\s?-_id\s?/;
 const excludeIdRegGlobal = /\s?-_id\s?/g;
 
-function populate(model, docs, options, callback) {
-  const populateOptions = options;
-  if (options.strictPopulate == null) {
-    if (options._localModel != null && options._localModel.schema._userProvidedOptions.strictPopulate != null) {
-      populateOptions.strictPopulate = options._localModel.schema._userProvidedOptions.strictPopulate;
-    } else if (options._localModel != null && model.base.options.strictPopulate != null) {
+async function _populatePath(model, docs, populateOptions) {
+  if (populateOptions.strictPopulate == null) {
+    if (populateOptions._localModel != null && populateOptions._localModel.schema._userProvidedOptions.strictPopulate != null) {
+      populateOptions.strictPopulate = populateOptions._localModel.schema._userProvidedOptions.strictPopulate;
+    } else if (populateOptions._localModel != null && model.base.options.strictPopulate != null) {
       populateOptions.strictPopulate = model.base.options.strictPopulate;
     } else if (model.base.options.strictPopulate != null) {
       populateOptions.strictPopulate = model.base.options.strictPopulate;
@@ -4317,15 +4287,12 @@ function populate(model, docs, options, callback) {
     docs = [docs];
   }
   if (docs.length === 0 || docs.every(utils.isNullOrUndefined)) {
-    return callback();
+    return;
   }
 
   const modelsMap = getModelsMapForPopulate(model, docs, populateOptions);
-
   if (modelsMap instanceof MongooseError) {
-    return immediate(function() {
-      callback(modelsMap);
-    });
+    throw modelsMap;
   }
   const len = modelsMap.length;
   let vals = [];
@@ -4335,7 +4302,6 @@ function populate(model, docs, options, callback) {
     return undefined !== item;
   }
 
-  let _remaining = len;
   let hasOne = false;
   const params = [];
   for (let i = 0; i < len; ++i) {
@@ -4366,7 +4332,6 @@ function populate(model, docs, options, callback) {
       // Ensure that we set to 0 or empty array even
       // if we don't actually execute a query to make sure there's a value
       // and we know this path was populated for future sets. See gh-7731, gh-8230
-      --_remaining;
       _assign(model, [], mod, assignmentOpts);
       continue;
     }
@@ -4397,64 +4362,50 @@ function populate(model, docs, options, callback) {
     } else if (mod.options.limit != null) {
       assignmentOpts.originalLimit = mod.options.limit;
     }
-    params.push([mod, match, select, assignmentOpts, _next]);
+    params.push([mod, match, select, assignmentOpts]);
   }
   if (!hasOne) {
     // If models but no docs, skip further deep populate.
     if (modelsMap.length !== 0) {
-      return callback();
+      return;
     }
-    // If no models to populate but we have a nested populate,
-    // keep trying, re: gh-8946
+    // If no models and no docs to populate but we have a nested populate,
+    // probably a case of unnecessarily populating a non-ref path re: gh-8946
     if (populateOptions.populate != null) {
       const opts = utils.populate(populateOptions.populate).map(pop => Object.assign({}, pop, {
         path: populateOptions.path + '.' + pop.path
       }));
-      model.populate(docs, opts).then(res => { callback(null, res); }, err => { callback(err); });
-      return;
+      return model.populate(docs, opts);
     }
-    return callback();
+    return;
   }
 
+  const promises = [];
   for (const arr of params) {
-    _execPopulateQuery.apply(null, arr);
-  }
-  function _next(err, valsFromDb) {
-    if (err != null) {
-      return callback(err, null);
-    }
-    vals = vals.concat(valsFromDb);
-    if (--_remaining === 0) {
-      _done();
-    }
+    promises.push(_execPopulateQuery.apply(null, arr).then(valsFromDb => { vals = vals.concat(valsFromDb); }));
   }
 
-  function _done() {
-    for (const arr of params) {
-      const mod = arr[0];
-      const assignmentOpts = arr[3];
-      for (const val of vals) {
-        mod.options._childDocs.push(val);
-      }
-      try {
-        _assign(model, vals, mod, assignmentOpts);
-      } catch (err) {
-        return callback(err);
-      }
-    }
+  await Promise.all(promises);
 
-    for (const arr of params) {
-      removeDeselectedForeignField(arr[0].foreignField, arr[0].options, vals);
+  for (const arr of params) {
+    const mod = arr[0];
+    const assignmentOpts = arr[3];
+    for (const val of vals) {
+      mod.options._childDocs.push(val);
     }
-    for (const arr of params) {
-      const mod = arr[0];
-      if (mod.options && mod.options.options && mod.options.options._leanTransform) {
-        for (const doc of vals) {
-          mod.options.options._leanTransform(doc);
-        }
+    _assign(model, vals, mod, assignmentOpts);
+  }
+
+  for (const arr of params) {
+    removeDeselectedForeignField(arr[0].foreignField, arr[0].options, vals);
+  }
+  for (const arr of params) {
+    const mod = arr[0];
+    if (mod.options && mod.options.options && mod.options.options._leanTransform) {
+      for (const doc of vals) {
+        mod.options.options._leanTransform(doc);
       }
     }
-    callback();
   }
 }
 
@@ -4462,7 +4413,7 @@ function populate(model, docs, options, callback) {
  * ignore
  */
 
-function _execPopulateQuery(mod, match, select, assignmentOpts, callback) {
+function _execPopulateQuery(mod, match, select) {
   let subPopulate = clone(mod.options.populate);
   const queryOptions = Object.assign({
     skip: mod.options.skip,
@@ -4528,15 +4479,12 @@ function _execPopulateQuery(mod, match, select, assignmentOpts, callback) {
     query.populate(subPopulate);
   }
 
-  query.exec().then(
+  return query.exec().then(
     docs => {
       for (const val of docs) {
         leanPopulateMap.set(val, mod.model);
       }
-      callback(null, docs);
-    },
-    err => {
-      callback(err);
+      return docs;
     }
   );
 }
@@ -4934,6 +4882,23 @@ Model.inspect = function() {
   return `Model { ${this.modelName} }`;
 };
 
+/**
+ * Return the MongoDB namespace for this model as a string. The namespace is the database name, followed by '.', followed by the collection name.
+ *
+ * #### Example:
+ *
+ *     const conn = mongoose.createConnection('mongodb://127.0.0.1:27017/mydb');
+ *     const TestModel = conn.model('Test', mongoose.Schema({ name: String }));
+ *
+ *     TestModel.namespace(); // 'mydb.tests'
+ *
+ * @api public
+ */
+
+Model.namespace = function namespace() {
+  return this.db.name + '.' + this.collection.collectionName;
+};
+
 if (util.inspect.custom) {
   // Avoid Node deprecation warning DEP0079
   Model[util.inspect.custom] = Model.inspect;

package/lib/mongoose.js

@@ -987,6 +987,7 @@ Mongoose.prototype.VirtualType = VirtualType;
  * - [ObjectId](https://mongoosejs.com/docs/schematypes.html#objectids)
  * - [Map](https://mongoosejs.com/docs/schematypes.html#maps)
  * - [Subdocument](https://mongoosejs.com/docs/schematypes.html#schemas)
+ * - [Int32](https://mongoosejs.com/docs/schematypes.html#int32)
  *
  * Using this exposed access to the `ObjectId` type, we can construct ids on demand.
  *
@@ -1138,6 +1139,7 @@ Mongoose.prototype.syncIndexes = function(options) {
 
 Mongoose.prototype.Decimal128 = SchemaTypes.Decimal128;
 
+
 /**
  * The Mongoose Mixed [SchemaType](https://mongoosejs.com/docs/schematypes.html). Used for
  * declaring paths in your schema that Mongoose's change tracking, casting,

package/lib/plugins/saveSubdocs.js

@@ -27,8 +27,10 @@ module.exports = function saveSubdocs(schema) {
         cb(err);
       });
     }, function(error) {
-      // Bust subdocs cache because subdoc pre hooks can add new subdocuments
-      _this.$__.saveOptions.__subdocs = null;
+      // Invalidate subdocs cache because subdoc pre hooks can add new subdocuments
+      if (_this.$__.saveOptions) {
+        _this.$__.saveOptions.__subdocs = null;
+      }
       if (error) {
         return _this.$__schema.s.hooks.execPost('save:error', _this, [_this], { error: error }, function(error) {
           next(error);

package/lib/query.js

@@ -2381,6 +2381,7 @@ Query.prototype._find = async function _find() {
       _completeManyLean(_this.model.schema, docs, null, completeManyOptions) :
       _this._completeMany(docs, fields, userProvidedFields, completeManyOptions);
   }
+
   const pop = helpers.preparePopulationOptionsMQ(_this, mongooseOptions);
 
   if (mongooseOptions.lean) {
@@ -4466,6 +4467,8 @@ Query.prototype.exec = async function exec(op) {
     } else {
       error = err;
     }
+
+    error = this.model.schema._transformDuplicateKeyError(error);
   }
 
   res = await _executePostHooks(this, res, error);
@@ -4762,12 +4765,13 @@ Query.prototype._castUpdate = function _castUpdate(obj) {
  */
 
 Query.prototype.populate = function() {
+  const args = Array.from(arguments);
   // Bail when given no truthy arguments
-  if (!Array.from(arguments).some(Boolean)) {
+  if (!args.some(Boolean)) {
     return this;
   }
 
-  const res = utils.populate.apply(null, arguments);
+  const res = utils.populate.apply(null, args);
 
   // Propagate readConcern and readPreference and lean from parent query,
   // unless one already specified

package/lib/queryHelpers.js

@@ -4,6 +4,7 @@
  * Module dependencies
  */
 
+const PopulateOptions = require('./options/populateOptions');
 const checkEmbeddedDiscriminatorKeyProjection =
   require('./helpers/discriminator/checkEmbeddedDiscriminatorKeyProjection');
 const get = require('./helpers/get');
@@ -13,32 +14,6 @@ const isDefiningProjection = require('./helpers/projection/isDefiningProjection'
 const clone = require('./helpers/clone');
 const isPathSelectedInclusive = require('./helpers/projection/isPathSelectedInclusive');
 
-/**
- * Prepare a set of path options for query population.
- *
- * @param {Query} query
- * @param {Object} options
- * @return {Array}
- */
-
-exports.preparePopulationOptions = function preparePopulationOptions(query, options) {
-  const _populate = query.options.populate;
-  const pop = Object.keys(_populate).reduce((vals, key) => vals.concat([_populate[key]]), []);
-
-  // lean options should trickle through all queries
-  if (options.lean != null) {
-    pop
-      .filter(p => (p && p.options && p.options.lean) == null)
-      .forEach(makeLean(options.lean));
-  }
-
-  pop.forEach(opts => {
-    opts._localModel = query.model;
-  });
-
-  return pop;
-};
-
 /**
  * Prepare a set of path options for query population. This is the MongooseQuery
  * version
@@ -73,12 +48,18 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
   }
 
   const projection = query._fieldsForExec();
-  pop.forEach(p => {
-    p._queryProjection = projection;
-  });
-  pop.forEach(opts => {
-    opts._localModel = query.model;
-  });
+  for (let i = 0; i < pop.length; ++i) {
+    if (pop[i] instanceof PopulateOptions) {
+      pop[i] = new PopulateOptions({
+        ...pop[i],
+        _queryProjection: projection,
+        _localModel: query.model
+      });
+    } else {
+      pop[i]._queryProjection = projection;
+      pop[i]._localModel = query.model;
+    }
+  }
 
   return pop;
 };

package/lib/schema/bigint.js

@@ -81,12 +81,12 @@ SchemaBigInt.setters = [];
 SchemaBigInt.get = SchemaType.get;
 
 /**
- * Get/set the function used to cast arbitrary values to booleans.
+ * Get/set the function used to cast arbitrary values to bigints.
  *
  * #### Example:
  *
  *     // Make Mongoose cast empty string '' to false.
- *     const original = mongoose.Schema.BigInt.cast();
+ *     const original = mongoose.Schema.Types.BigInt.cast();
  *     mongoose.Schema.BigInt.cast(v => {
  *       if (v === '') {
  *         return false;

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