mongoose 8.8.4 → 8.9.1

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);
@@ -2230,7 +2231,7 @@ Model.$where = function $where() {
 /**
  * Issues a mongodb findOneAndUpdate command.
  *
- * Finds a matching document, updates it according to the `update` arg, passing any `options`, and returns the found document (if any) to the callback. The query executes if `callback` is passed else a Query object is returned.
+ * Finds a matching document, updates it according to the `update` arg, passing any `options`. A Query object is returned.
  *
  * #### Example:
  *
@@ -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) {
@@ -3642,7 +3643,11 @@ Model.castObject = function castObject(obj, options) {
   options = options || {};
   const ret = {};
 
-  const schema = this.schema;
+  let schema = this.schema;
+  const discriminatorKey = schema.options.discriminatorKey;
+  if (schema.discriminators != null && obj != null && obj[discriminatorKey] != null) {
+    schema = getSchemaDiscriminatorByValue(schema, obj[discriminatorKey]) || schema;
+  }
   const paths = Object.keys(schema.paths);
 
   for (const path of paths) {
@@ -3991,7 +3996,7 @@ function _update(model, op, conditions, doc, options) {
 /**
  * Performs [aggregations](https://www.mongodb.com/docs/manual/aggregation/) on the models collection.
  *
- * If a `callback` is passed, the `aggregate` is executed and a `Promise` is returned. If a callback is not passed, the `aggregate` itself is returned.
+ * The `aggregate` itself is returned.
  *
  * This function triggers the following middleware.
  *
@@ -4046,10 +4051,6 @@ Model.aggregate = function aggregate(pipeline, options) {
     aggregate.option(options);
   }
 
-  if (typeof callback === 'undefined') {
-    return aggregate;
-  }
-
   return aggregate;
 };
 
@@ -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,7 +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 {Function} [callback(err,doc)] Optional callback, executed upon completion. Receives `err` and the `doc(s)`.
+ * @param {Boolean} [options.forceRepopulate=true] Set to `false` to prevent Mongoose from repopulating paths that are already populated
  * @return {Promise}
  * @api public
  */
@@ -4245,67 +4247,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 +4286,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 +4301,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 +4331,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 +4361,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 +4412,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 +4478,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 +4881,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

@@ -245,7 +245,7 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
  * @api public
  */
 
-Mongoose.prototype.set = function(key, value) {
+Mongoose.prototype.set = function getsetOptions(key, value) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   if (arguments.length === 1 && typeof key !== 'object') {
@@ -376,7 +376,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @api public
  */
 
-Mongoose.prototype.createConnection = function(uri, options) {
+Mongoose.prototype.createConnection = function createConnection(uri, options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   const Connection = _mongoose.__driver.Connection;
@@ -427,7 +427,6 @@ Mongoose.prototype.createConnection = function(uri, options) {
  * @param {Number} [options.socketTimeoutMS=0] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. `socketTimeoutMS` defaults to 0, which means Node.js will not time out the socket due to inactivity. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {Number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
  * @param {Boolean} [options.autoCreate=false] Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection.
- * @param {Function} [callback]
  * @see Mongoose#createConnection https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.createConnection()
  * @api public
  * @return {Promise} resolves to `this` if connection succeeded
@@ -479,12 +478,11 @@ Mongoose.prototype.disconnect = async function disconnect() {
  *
  * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/MongoClient.html#startSession)
  * @param {Boolean} [options.causalConsistency=true] set to false to disable causal consistency
- * @param {Function} [callback]
  * @return {Promise<ClientSession>} promise that resolves to a MongoDB driver `ClientSession`
  * @api public
  */
 
-Mongoose.prototype.startSession = function() {
+Mongoose.prototype.startSession = function startSession() {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   return _mongoose.connection.startSession.apply(_mongoose.connection, arguments);
@@ -498,7 +496,7 @@ Mongoose.prototype.startSession = function() {
  * @api public
  */
 
-Mongoose.prototype.pluralize = function(fn) {
+Mongoose.prototype.pluralize = function pluralize(fn) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   if (arguments.length > 0) {
@@ -561,7 +559,7 @@ Mongoose.prototype.pluralize = function(fn) {
  * @api public
  */
 
-Mongoose.prototype.model = function(name, schema, collection, options) {
+Mongoose.prototype.model = function model(name, schema, collection, options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   if (typeof schema === 'string') {
@@ -572,7 +570,7 @@ Mongoose.prototype.model = function(name, schema, collection, options) {
   if (arguments.length === 1) {
     const model = _mongoose.models[name];
     if (!model) {
-      throw new MongooseError.MissingSchemaError(name);
+      throw new _mongoose.Error.MissingSchemaError(name);
     }
     return model;
   }
@@ -581,7 +579,7 @@ Mongoose.prototype.model = function(name, schema, collection, options) {
     schema = new Schema(schema);
   }
   if (schema && !(schema instanceof Schema)) {
-    throw new Error('The 2nd parameter to `mongoose.model()` should be a ' +
+    throw new _mongoose.Error('The 2nd parameter to `mongoose.model()` should be a ' +
       'schema or a POJO');
   }
 
@@ -632,7 +630,7 @@ Mongoose.prototype.model = function(name, schema, collection, options) {
  * ignore
  */
 
-Mongoose.prototype._model = function(name, schema, collection, options) {
+Mongoose.prototype._model = function _model(name, schema, collection, options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   let model;
@@ -707,7 +705,7 @@ Mongoose.prototype._model = function(name, schema, collection, options) {
  * @return {Mongoose} this
  */
 
-Mongoose.prototype.deleteModel = function(name) {
+Mongoose.prototype.deleteModel = function deleteModel(name) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   _mongoose.connection.deleteModel(name);
@@ -726,7 +724,7 @@ Mongoose.prototype.deleteModel = function(name) {
  * @return {Array}
  */
 
-Mongoose.prototype.modelNames = function() {
+Mongoose.prototype.modelNames = function modelNames() {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   const names = Object.keys(_mongoose.models);
@@ -740,7 +738,7 @@ Mongoose.prototype.modelNames = function() {
  * @api private
  */
 
-Mongoose.prototype._applyPlugins = function(schema, options) {
+Mongoose.prototype._applyPlugins = function _applyPlugins(schema, options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   options = options || {};
@@ -763,7 +761,7 @@ Mongoose.prototype._applyPlugins = function(schema, options) {
  * @api public
  */
 
-Mongoose.prototype.plugin = function(fn, opts) {
+Mongoose.prototype.plugin = function plugin(fn, opts) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   _mongoose.plugins.push([fn, opts]);
@@ -987,6 +985,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.
  *
@@ -1072,7 +1071,7 @@ Mongoose.prototype.ObjectId = SchemaTypes.ObjectId;
  * @api public
  */
 
-Mongoose.prototype.isValidObjectId = function(v) {
+Mongoose.prototype.isValidObjectId = function isValidObjectId(v) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
   return _mongoose.Types.ObjectId.isValid(v);
 };
@@ -1104,7 +1103,7 @@ Mongoose.prototype.isValidObjectId = function(v) {
  * @api public
  */
 
-Mongoose.prototype.isObjectIdOrHexString = function(v) {
+Mongoose.prototype.isObjectIdOrHexString = function isObjectIdOrHexString(v) {
   return isBsonType(v, 'ObjectId') || (typeof v === 'string' && objectIdHexRegexp.test(v));
 };
 
@@ -1116,7 +1115,7 @@ Mongoose.prototype.isObjectIdOrHexString = function(v) {
  * @param {Boolean} options.continueOnError `false` by default. If set to `true`, mongoose will not throw an error if one model syncing failed, and will return an object where the keys are the names of the models, and the values are the results/errors for each model.
  * @return {Promise} Returns a Promise, when the Promise resolves the value is a list of the dropped indexes.
  */
-Mongoose.prototype.syncIndexes = function(options) {
+Mongoose.prototype.syncIndexes = function syncIndexes(options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
   return _mongoose.connection.syncIndexes(options);
 };
@@ -1138,6 +1137,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,
@@ -1190,8 +1190,8 @@ Mongoose.prototype.Number = SchemaTypes.Number;
  * @api public
  */
 
-Mongoose.prototype.Error = require('./error/index');
-Mongoose.prototype.MongooseError = require('./error/mongooseError');
+Mongoose.prototype.Error = MongooseError;
+Mongoose.prototype.MongooseError = MongooseError;
 
 /**
  * Mongoose uses this function to get the current time when setting
@@ -1216,7 +1216,7 @@ Mongoose.prototype.now = function now() { return new Date(); };
  * @api public
  */
 
-Mongoose.prototype.CastError = require('./error/cast');
+Mongoose.prototype.CastError = MongooseError.CastError;
 
 /**
  * The constructor used for schematype options

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) {
@@ -3196,7 +3197,6 @@ Query.prototype.deleteMany = function(filter, options) {
 /**
  * Execute a `deleteMany()` query
  *
- * @param {Function} callback
  * @method _deleteMany
  * @instance
  * @memberOf Query
@@ -3489,13 +3489,6 @@ Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
  * - `sort`: if multiple docs are found by the conditions, sets the sort order to choose which doc to update
  * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
  *
- * #### Callback Signature
- *
- *     function(error, doc) {
- *       // error: any errors that occurred
- *       // doc: the document before updates are applied if `new: false`, or after updates if `new = true`
- *     }
- *
  * #### Example:
  *
  *     A.where().findOneAndDelete(conditions, options)  // return Query
@@ -3586,13 +3579,6 @@ Query.prototype._findOneAndDelete = async function _findOneAndDelete() {
  * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
  * - `includeResultMetadata`: if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
  *
- * #### Callback Signature
- *
- *     function(error, doc) {
- *       // error: any errors that occurred
- *       // doc: the document before updates are applied if `new: false`, or after updates if `new = true`
- *     }
- *
  * #### Example:
  *
  *     A.where().findOneAndReplace(filter, replacement, options); // return Query
@@ -4024,7 +4010,6 @@ Query.prototype._replaceOne = async function _replaceOne() {
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @param {Boolean} [options.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
- * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
  * @see Query docs https://mongoosejs.com/docs/queries.html
@@ -4095,7 +4080,6 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @param {Boolean} [options.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
- * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
  * @see Query docs https://mongoosejs.com/docs/queries.html
@@ -4162,7 +4146,6 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
- * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
  * @see Query docs https://mongoosejs.com/docs/queries.html
@@ -4466,6 +4449,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 +4747,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;