mongoose 8.20.0 → 9.0.0-rc0

package/lib/model.js

@@ -104,7 +104,9 @@ const saveToObjectOptions = Object.assign({}, internalToObjectOptions, {
  *
  * @param {Object} doc values for initial set
  * @param {Object} [fields] optional object containing the fields that were selected in the query which returned this document. You do **not** need to set this parameter to ensure Mongoose handles your [query projection](https://mongoosejs.com/docs/api/query.html#Query.prototype.select()).
- * @param {Boolean} [skipId=false] optional boolean. If true, mongoose doesn't add an `_id` field to the document.
+ * @param {Object} [options] optional object containing the options for the document.
+ * @param {Boolean} [options.defaults=true] if `false`, skip applying default values to this document.
+ * @param {Boolean} [options.skipId=false] By default, Mongoose document if one is not provided and the document's schema does not override Mongoose's default `_id`. Set `skipId` to `true` to skip this generation step.
  * @inherits Document https://mongoosejs.com/docs/api/document.html
  * @event `error`: If listening to this event, 'error' is emitted when a document was saved and an `error` occurred. If not listening, the event bubbles to the connection used to create this Model.
  * @event `index`: Emitted after `Model#ensureIndexes` completes. If an error occurred it is passed with the event.
@@ -113,7 +115,7 @@ const saveToObjectOptions = Object.assign({}, internalToObjectOptions, {
  * @api public
  */
 
-function Model(doc, fields, skipId) {
+function Model(doc, fields, options) {
   if (fields instanceof Schema) {
     throw new TypeError('2nd argument to `Model` constructor must be a POJO or string, ' +
       '**not** a schema. Make sure you\'re calling `mongoose.model()`, not ' +
@@ -124,7 +126,7 @@ function Model(doc, fields, skipId) {
       '**not** a string. Make sure you\'re calling `mongoose.model()`, not ' +
       '`mongoose.Model()`.');
   }
-  Document.call(this, doc, fields, skipId);
+  Document.call(this, doc, fields, options);
 }
 
 /**
@@ -316,11 +318,10 @@ function _applyCustomWhere(doc, where) {
 /*!
  * ignore
  */
-
-Model.prototype.$__handleSave = function(options, callback) {
+function _createSaveOptions(doc, options) {
   const saveOptions = {};
 
-  applyWriteConcern(this.$__schema, options);
+  applyWriteConcern(doc.$__schema, options);
   if (typeof options.writeConcern !== 'undefined') {
     saveOptions.writeConcern = {};
     if ('w' in options.writeConcern) {
@@ -347,215 +348,180 @@ Model.prototype.$__handleSave = function(options, callback) {
     saveOptions.checkKeys = options.checkKeys;
   }
 
-  const session = this.$session();
-  const asyncLocalStorage = this[modelDbSymbol].base.transactionAsyncLocalStorage?.getStore();
+  const session = doc.$session();
+  const asyncLocalStorage = doc[modelDbSymbol].base.transactionAsyncLocalStorage?.getStore();
   if (session != null) {
     saveOptions.session = session;
   } else if (!options.hasOwnProperty('session') && asyncLocalStorage?.session != null) {
     // Only set session from asyncLocalStorage if `session` option wasn't originally passed in options
     saveOptions.session = asyncLocalStorage.session;
   }
-  if (this.$isNew) {
-    // send entire doc
-    const obj = this.toObject(saveToObjectOptions);
-    if ((obj || {})._id === void 0) {
-      // documents must have an _id else mongoose won't know
-      // what to update later if more changes are made. the user
-      // wouldn't know what _id was generated by mongodb either
-      // nor would the ObjectId generated by mongodb necessarily
-      // match the schema definition.
-      immediate(function() {
-        callback(new MongooseError('document must have an _id before saving'));
-      });
-      return;
-    }
 
-    this.$__version(true, obj);
-    this[modelCollectionSymbol].insertOne(obj, saveOptions).then(
-      ret => callback(null, ret),
-      err => {
-        _setIsNew(this, true);
+  return saveOptions;
+}
 
-        callback(err, null);
-      }
-    );
+/*!
+ * ignore
+ */
 
-    this.$__reset();
-    _setIsNew(this, false);
-    // Make it possible to retry the insert
-    this.$__.inserting = true;
+Model.prototype.$__save = async function $__save(options) {
+  try {
+    await this._execDocumentPreHooks('save', options);
+  } catch (error) {
+    await this._execDocumentPostHooks('save', error);
     return;
   }
 
-  // Make sure we don't treat it as a new object on error,
-  // since it already exists
-  this.$__.inserting = false;
-  const delta = this.$__delta();
 
-  if (options.pathsToSave) {
-    for (const key in delta[1]['$set']) {
-      if (options.pathsToSave.includes(key)) {
-        continue;
-      } else if (options.pathsToSave.some(pathToSave => key.slice(0, pathToSave.length) === pathToSave && key.charAt(pathToSave.length) === '.')) {
-        continue;
-      } else {
-        delete delta[1]['$set'][key];
+  let result = null;
+  let where = null;
+  try {
+    const saveOptions = _createSaveOptions(this, options);
+
+    if (this.$isNew) {
+      // send entire doc
+      const obj = this.toObject(saveToObjectOptions);
+      if ((obj || {})._id === void 0) {
+        // documents must have an _id else mongoose won't know
+        // what to update later if more changes are made. the user
+        // wouldn't know what _id was generated by mongodb either
+        // nor would the ObjectId generated by mongodb necessarily
+        // match the schema definition.
+        throw new MongooseError('document must have an _id before saving');
       }
-    }
-  }
-  if (delta) {
-    if (delta instanceof MongooseError) {
-      callback(delta);
-      return;
-    }
-
-    const where = this.$__where(delta[0]);
-    if (where instanceof MongooseError) {
-      callback(where);
-      return;
-    }
-
-    _applyCustomWhere(this, where);
 
-    const update = delta[1];
-    if (this.$__schema.options.minimize) {
-      for (const updateOp of Object.values(update)) {
-        if (updateOp == null) {
-          continue;
-        }
-        for (const key of Object.keys(updateOp)) {
-          if (updateOp[key] == null || typeof updateOp[key] !== 'object') {
+      this.$__version(true, obj);
+      this.$__reset();
+      _setIsNew(this, false);
+      // Make it possible to retry the insert
+      this.$__.inserting = true;
+      result = await this[modelCollectionSymbol].insertOne(obj, saveOptions).catch(err => {
+        _setIsNew(this, true);
+        throw err;
+      });
+    } else {
+      // Make sure we don't treat it as a new object on error,
+      // since it already exists
+      this.$__.inserting = false;
+      const delta = this.$__delta();
+
+      if (options.pathsToSave) {
+        for (const key in delta[1]['$set']) {
+          if (options.pathsToSave.includes(key)) {
             continue;
-          }
-          if (!utils.isPOJO(updateOp[key])) {
+          } else if (options.pathsToSave.some(pathToSave => key.slice(0, pathToSave.length) === pathToSave && key.charAt(pathToSave.length) === '.')) {
             continue;
-          }
-          minimize(updateOp[key]);
-          if (Object.keys(updateOp[key]).length === 0) {
-            delete updateOp[key];
-            update.$unset = update.$unset || {};
-            update.$unset[key] = 1;
+          } else {
+            delete delta[1]['$set'][key];
           }
         }
       }
-    }
+      if (delta) {
+        where = this.$__where(delta[0]);
+        _applyCustomWhere(this, where);
+
+        const update = delta[1];
+        if (this.$__schema.options.minimize) {
+          for (const updateOp of Object.values(update)) {
+            if (updateOp == null) {
+              continue;
+            }
+            for (const key of Object.keys(updateOp)) {
+              if (updateOp[key] == null || typeof updateOp[key] !== 'object') {
+                continue;
+              }
+              if (!utils.isPOJO(updateOp[key])) {
+                continue;
+              }
+              minimize(updateOp[key]);
+              if (Object.keys(updateOp[key]).length === 0) {
+                delete updateOp[key];
+                update.$unset = update.$unset || {};
+                update.$unset[key] = 1;
+              }
+            }
+          }
+        }
 
-    this[modelCollectionSymbol].updateOne(where, update, saveOptions).then(
-      ret => {
-        if (ret == null) {
-          ret = { $where: where };
-        } else {
-          ret.$where = where;
+        // store the modified paths before the document is reset
+        this.$__.modifiedPaths = this.modifiedPaths();
+        this.$__reset();
+
+        _setIsNew(this, false);
+        result = await this[modelCollectionSymbol].updateOne(where, update, saveOptions).catch(err => {
+          this.$__undoReset();
+          throw err;
+        });
+      } else {
+        where = this.$__where();
+        _applyCustomWhere(this, where);
+        if (this.$__.version) {
+          this.$__version(where, delta);
         }
-        callback(null, ret);
-      },
-      err => {
-        this.$__undoReset();
 
-        callback(err);
+        applyReadConcern(this.$__schema, saveOptions);
+        result = await this.constructor.collection.findOne(where, saveOptions)
+          .then(documentExists => ({ matchedCount: !documentExists ? 0 : 1 }));
       }
-    );
-  } else {
-    handleEmptyUpdate.call(this);
+    }
+  } catch (err) {
+    const error = this.$__schema._transformDuplicateKeyError(err);
+    await this._execDocumentPostHooks('save', error);
     return;
   }
 
-  // store the modified paths before the document is reset in case we need to generate version error.
-  this.$__.modifiedPaths = this.modifiedPaths().concat(Object.keys(this.$__.activePaths.getStatePaths('default')));
-  this.$__reset();
-
-  _setIsNew(this, false);
-
-  function handleEmptyUpdate() {
-    const optionsWithCustomValues = Object.assign({}, options, saveOptions);
-    const where = this.$__where();
-    const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
-    if (optimisticConcurrency && !Array.isArray(optimisticConcurrency)) {
-      const key = this.$__schema.options.versionKey;
-      const val = this.$__getValue(key);
-      if (val != null) {
-        where[key] = val;
+  let numAffected = 0;
+  const writeConcern = options != null ?
+    options.writeConcern != null ?
+      options.writeConcern.w :
+      options.w :
+    0;
+  if (writeConcern !== 0) {
+    // Skip checking if write succeeded if writeConcern is set to
+    // unacknowledged writes, because otherwise `numAffected` will always be 0
+    if (result != null) {
+      if (Array.isArray(result)) {
+        numAffected = result.length;
+      } else if (result.matchedCount != null) {
+        numAffected = result.matchedCount;
+      } else {
+        numAffected = result;
       }
     }
 
-    applyReadConcern(this.$__schema, optionsWithCustomValues);
-    this.constructor.collection.findOne(where, optionsWithCustomValues)
-      .then(documentExists => {
-        const matchedCount = !documentExists ? 0 : 1;
-        callback(null, { $where: where, matchedCount });
-      })
-      .catch(callback);
-  }
-};
-
-/*!
- * ignore
- */
-
-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);
-      });
-    }
-    let numAffected = 0;
-    const writeConcern = options != null ?
-      options.writeConcern != null ?
-        options.writeConcern.w :
-        options.w :
-      0;
-    if (writeConcern !== 0) {
-      // Skip checking if write succeeded if writeConcern is set to
-      // unacknowledged writes, because otherwise `numAffected` will always be 0
-      if (result != null) {
-        if (Array.isArray(result)) {
-          numAffected = result.length;
-        } else if (result.matchedCount != null) {
-          numAffected = result.matchedCount;
-        } else {
-          numAffected = result;
-        }
+    const versionBump = this.$__.version;
+    // was this an update that required a version bump?
+    if (versionBump && !this.$__.inserting) {
+      const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
+      this.$__.version = undefined;
+      const key = this.$__schema.options.versionKey;
+      const version = this.$__getValue(key) || 0;
+      if (numAffected <= 0) {
+        // the update failed. pass an error back
+        this.$__undoReset();
+        const err = this.$__.$versionError ||
+          new VersionError(this, version, this.$__.modifiedPaths);
+        await this._execDocumentPostHooks('save', err);
+        return;
       }
 
-      const versionBump = this.$__.version;
-      // was this an update that required a version bump?
-      if (versionBump && !this.$__.inserting) {
-        const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
-        this.$__.version = undefined;
-        const key = this.$__schema.options.versionKey;
-        const version = this.$__getValue(key) || 0;
-        if (numAffected <= 0) {
-          // the update failed. pass an error back
-          this.$__undoReset();
-          const err = this.$__.$versionError ||
-            new VersionError(this, version, this.$__.modifiedPaths);
-          return callback(err, this);
-        }
-
-        // increment version if was successful
-        if (doIncrement) {
-          this.$__setValue(key, version + 1);
-        }
-      }
-      if (result != null && numAffected <= 0) {
-        this.$__undoReset();
-        error = new DocumentNotFoundError(result.$where,
-          this.constructor.modelName, numAffected, result);
-        const hooks = this.$__schema.s.hooks;
-        return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
-          callback(error, this);
-        });
+      // increment version if was successful
+      if (doIncrement) {
+        this.$__setValue(key, version + 1);
       }
     }
-    this.$__.saving = undefined;
-    this.$__.savedState = {};
-    this.$emit('save', this, numAffected);
-    this.constructor.emit('save', this, numAffected);
-    callback(null, this);
-  });
+    if (result != null && numAffected <= 0) {
+      this.$__undoReset();
+      const error = new DocumentNotFoundError(where, this.constructor.modelName, numAffected, result);
+      await this._execDocumentPostHooks('save', error);
+      return;
+    }
+  }
+  this.$__.saving = undefined;
+  this.$__.savedState = {};
+  this.$emit('save', this, numAffected);
+  this.constructor.emit('save', this, numAffected);
+  await this._execDocumentPostHooks('save');
 };
 
 /*!
@@ -639,20 +605,17 @@ Model.prototype.save = async function save(options) {
 
   this.$__.saveOptions = options;
 
-  await new Promise((resolve, reject) => {
-    this.$__save(options, error => {
-      this.$__.saving = null;
-      this.$__.saveOptions = null;
-      this.$__.$versionError = null;
-      this.$op = null;
-      if (error != null) {
-        this.$__handleReject(error);
-        return reject(error);
-      }
-
-      resolve();
-    });
-  });
+  try {
+    await this.$__save(options);
+  } catch (error) {
+    this.$__handleReject(error);
+    throw error;
+  } finally {
+    this.$__.saving = null;
+    this.$__.saveOptions = null;
+    this.$__.$versionError = null;
+    this.$op = null;
+  }
 
   return this;
 };
@@ -750,7 +713,7 @@ Model.prototype.$__where = function _where(where) {
   }
 
   if (this._doc._id === void 0) {
-    return new MongooseError('No _id found on document!');
+    throw new MongooseError('No _id found on document!');
   }
 
   return where;
@@ -791,9 +754,6 @@ Model.prototype.deleteOne = function deleteOne(options) {
 
   const self = this;
   const where = this.$__where();
-  if (where instanceof Error) {
-    throw where;
-  }
   const query = self.constructor.deleteOne(where, options);
 
   if (this.$session() != null) {
@@ -803,36 +763,32 @@ Model.prototype.deleteOne = function deleteOne(options) {
   }
 
   query.pre(async function queryPreDeleteOne() {
-    await new Promise((resolve, reject) => {
-      self.constructor._middleware.execPre('deleteOne', self, [self], err => {
-        if (err) reject(err);
-        else resolve();
-      });
-    });
+    const res = await self.constructor._middleware.execPre('deleteOne', self, [self]);
+    // `self` is passed to pre hooks as argument for backwards compatibility, but that
+    // isn't the actual arguments passed to the wrapped function.
+    if (res?.length !== 1 || res[0] !== self) {
+      throw new Error('Document deleteOne pre hooks cannot overwrite arguments');
+    }
     // Apply custom where conditions _after_ document deleteOne middleware for
     // consistency with save() - sharding plugin needs to set $where
     if (self.$where != null) {
       this.where(self.$where);
     }
+    return res;
   });
-  query.pre(function callSubdocPreHooks(cb) {
-    each(self.$getAllSubdocs(), (subdoc, cb) => {
-      subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc], cb);
-    }, cb);
+  query.pre(function callSubdocPreHooks() {
+    return Promise.all(self.$getAllSubdocs().map(subdoc => subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc])));
   });
-  query.pre(function skipIfAlreadyDeleted(cb) {
+  query.pre(function skipIfAlreadyDeleted() {
     if (self.$__.isDeleted) {
-      return cb(Kareem.skipWrappedFunction());
+      throw new Kareem.skipWrappedFunction();
     }
-    return cb();
   });
-  query.post(function callSubdocPostHooks(cb) {
-    each(self.$getAllSubdocs(), (subdoc, cb) => {
-      subdoc.constructor._middleware.execPost('deleteOne', subdoc, [subdoc], {}, cb);
-    }, cb);
+  query.post(function callSubdocPostHooks() {
+    return Promise.all(self.$getAllSubdocs().map(subdoc => subdoc.constructor._middleware.execPost('deleteOne', subdoc, [subdoc])));
   });
-  query.post(function queryPostDeleteOne(cb) {
-    self.constructor._middleware.execPost('deleteOne', self, [self], {}, cb);
+  query.post(function queryPostDeleteOne() {
+    return self.constructor._middleware.execPost('deleteOne', self, [self], {});
   });
 
   return query;
@@ -1183,16 +1139,11 @@ Model.createCollection = async function createCollection(options) {
     throw new MongooseError('Model.createCollection() no longer accepts a callback');
   }
 
-  const shouldSkip = await new Promise((resolve, reject) => {
-    this.hooks.execPre('createCollection', this, [options], (err) => {
-      if (err != null) {
-        if (err instanceof Kareem.skipWrappedFunction) {
-          return resolve(true);
-        }
-        return reject(err);
-      }
-      resolve();
-    });
+  [options] = await this.hooks.execPre('createCollection', this, [options]).catch(err => {
+    if (err instanceof Kareem.skipWrappedFunction) {
+      return [err];
+    }
+    throw err;
   });
 
   const collectionOptions = this &&
@@ -1248,31 +1199,16 @@ Model.createCollection = async function createCollection(options) {
   }
 
   try {
-    if (!shouldSkip) {
+    if (!(options instanceof Kareem.skipWrappedFunction)) {
       await this.db.createCollection(this.$__collection.collectionName, options);
     }
   } catch (err) {
     if (err != null && (err.name !== 'MongoServerError' || err.code !== 48)) {
-      await new Promise((resolve, reject) => {
-        const _opts = { error: err };
-        this.hooks.execPost('createCollection', this, [null], _opts, (err) => {
-          if (err != null) {
-            return reject(err);
-          }
-          resolve();
-        });
-      });
+      await this.hooks.execPost('createCollection', this, [null], { error: err });
     }
   }
 
-  await new Promise((resolve, reject) => {
-    this.hooks.execPost('createCollection', this, [this.$__collection], (err) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve();
-    });
-  });
+  await this.hooks.execPost('createCollection', this, [this.$__collection]);
 
   return this.$__collection;
 };
@@ -1306,7 +1242,6 @@ Model.createCollection = async function createCollection(options) {
  *     toCreate; // Array of strings containing names of indexes that `syncIndexes()` will create
  *
  * @param {Object} [options] options to pass to `ensureIndexes()`
- * @param {Boolean} [options.background=null] if specified, overrides each index's `background` property
  * @param {Boolean} [options.hideIndexes=false] set to `true` to hide indexes instead of dropping. Requires MongoDB server 4.4 or higher
  * @return {Promise}
  * @api public
@@ -1708,8 +1643,7 @@ function _ensureIndexes(model, options, callback) {
     });
     return;
   }
-  // Indexes are created one-by-one to support how MongoDB < 2.4 deals
-  // with background indexes.
+  // Indexes are created one-by-one
 
   const indexSingleDone = function(err, fields, options, name) {
     model.emit('index-single-done', err, fields, options, name);
@@ -1761,10 +1695,6 @@ function _ensureIndexes(model, options, callback) {
 
     indexSingleStart(indexFields, options);
 
-    if ('background' in options) {
-      indexOptions.background = options.background;
-    }
-
     // Just in case `createIndex()` throws a sync error
     let promise = null;
     try {
@@ -2890,6 +2820,13 @@ Model.insertOne = async function insertOne(doc, options) {
 Model.watch = function(pipeline, options) {
   _checkContext(this, 'watch');
 
+  options = options || {};
+  const watchOptions = options?.hydrate !== undefined ?
+    utils.omit(options, ['hydrate']) :
+    { ...options };
+  options.model = this;
+
+
   const changeStreamThunk = cb => {
     pipeline = pipeline || [];
     prepareDiscriminatorPipeline(pipeline, this.schema, 'fullDocument');
@@ -2898,18 +2835,15 @@ Model.watch = function(pipeline, options) {
         if (this.closed) {
           return;
         }
-        const driverChangeStream = this.$__collection.watch(pipeline, options);
+        const driverChangeStream = this.$__collection.watch(pipeline, watchOptions);
         cb(null, driverChangeStream);
       });
     } else {
-      const driverChangeStream = this.$__collection.watch(pipeline, options);
+      const driverChangeStream = this.$__collection.watch(pipeline, watchOptions);
       cb(null, driverChangeStream);
     }
   };
 
-  options = options || {};
-  options.model = this;
-
   return new ChangeStream(changeStreamThunk, pipeline, options);
 };
 
@@ -2995,37 +2929,14 @@ Model.insertMany = async function insertMany(arr, options) {
     throw new MongooseError('Model.insertMany() no longer accepts a callback');
   }
 
-  return new Promise((resolve, reject) => {
-    this.$__insertMany(arr, options, (err, res) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve(res);
-    });
-  });
-};
-
-/**
- * ignore
- *
- * @param {Array} arr
- * @param {Object} options
- * @param {Function} callback
- * @api private
- * @memberOf Model
- * @method $__insertMany
- * @static
- */
-
-Model.$__insertMany = function(arr, options, callback) {
-  const _this = this;
-  if (typeof options === 'function') {
-    callback = options;
-    options = null;
+  try {
+    [arr] = await this._middleware.execPre('insertMany', this, [arr]);
+  } catch (error) {
+    await this._middleware.execPost('insertMany', this, [arr], { error });
   }
 
-  callback = callback || utils.noop;
   options = options || {};
+  const ThisModel = this;
   const limit = options.limit || 1000;
   const rawResult = !!options.rawResult;
   const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
@@ -3044,238 +2955,212 @@ Model.$__insertMany = function(arr, options, callback) {
   const validationErrors = [];
   const validationErrorsToOriginalOrder = new Map();
   const results = ordered ? null : new Array(arr.length);
-  const toExecute = arr.map((doc, index) =>
-    callback => {
-      // If option `lean` is set to true bypass validation and hydration
-      if (lean) {
-        // we have to execute callback at the nextTick to be compatible
-        // with parallelLimit, as `results` variable has TDZ issue if we
-        // execute the callback synchronously
-        return immediate(() => callback(null, doc));
-      }
-      let createdNewDoc = false;
-      if (!(doc instanceof _this)) {
-        if (doc != null && typeof doc !== 'object') {
-          return callback(new ObjectParameterError(doc, 'arr.' + index, 'insertMany'));
-        }
-        try {
-          doc = new _this(doc);
-          createdNewDoc = true;
-        } catch (err) {
-          return callback(err);
-        }
+  async function validateDoc(doc, index) {
+    // If option `lean` is set to true bypass validation and hydration
+    if (lean) {
+      return doc;
+    }
+    let createdNewDoc = false;
+    if (!(doc instanceof ThisModel)) {
+      if (doc != null && typeof doc !== 'object') {
+        throw new ObjectParameterError(doc, 'arr.' + index, 'insertMany');
       }
+      doc = new ThisModel(doc);
+      createdNewDoc = true;
+    }
 
-      if (options.session != null) {
-        doc.$session(options.session);
-      }
-      // If option `lean` is set to true bypass validation
-      if (lean) {
-        // we have to execute callback at the nextTick to be compatible
-        // with parallelLimit, as `results` variable has TDZ issue if we
-        // execute the callback synchronously
-        return immediate(() => callback(null, doc));
-      }
-      doc.$validate(createdNewDoc ? { _skipParallelValidateCheck: true } : null).then(
-        () => { callback(null, doc); },
-        error => {
-          if (ordered === false) {
-            // Add index to validation error so users can identify which document failed
-            error.index = index;
-            validationErrors.push(error);
-            validationErrorsToOriginalOrder.set(error, index);
-            results[index] = error;
-            return callback(null, null);
-          }
-          callback(error);
+    if (options.session != null) {
+      doc.$session(options.session);
+    }
+    return doc.$validate(createdNewDoc ? { _skipParallelValidateCheck: true } : null)
+      .then(() => doc)
+      .catch(error => {
+        if (ordered === false) {
+          error.index = index;
+          validationErrors.push(error);
+          validationErrorsToOriginalOrder.set(error, index);
+          results[index] = error;
+          return;
         }
-      );
-    });
+        throw error;
+      });
+  }
 
-  parallelLimit(toExecute, limit, function(error, docs) {
-    if (error) {
-      callback(error, null);
-      return;
-    }
+  const docs = await parallelLimit(arr, validateDoc, limit);
 
-    const originalDocIndex = new Map();
-    const validDocIndexToOriginalIndex = new Map();
-    for (let i = 0; i < docs.length; ++i) {
-      originalDocIndex.set(docs[i], i);
-    }
+  const originalDocIndex = new Map();
+  const validDocIndexToOriginalIndex = new Map();
+  for (let i = 0; i < docs.length; ++i) {
+    originalDocIndex.set(docs[i], i);
+  }
+
+  // We filter all failed pre-validations by removing nulls
+  const docAttributes = docs.filter(function(doc) {
+    return doc != null;
+  });
+  for (let i = 0; i < docAttributes.length; ++i) {
+    validDocIndexToOriginalIndex.set(i, originalDocIndex.get(docAttributes[i]));
+  }
 
-    // We filter all failed pre-validations by removing nulls
-    const docAttributes = docs.filter(function(doc) {
-      return doc != null;
+  // Make sure validation errors are in the same order as the
+  // original documents, so if both doc1 and doc2 both fail validation,
+  // `Model.insertMany([doc1, doc2])` will always have doc1's validation
+  // error before doc2's. Re: gh-12791.
+  if (validationErrors.length > 0) {
+    validationErrors.sort((err1, err2) => {
+      return validationErrorsToOriginalOrder.get(err1) - validationErrorsToOriginalOrder.get(err2);
     });
-    for (let i = 0; i < docAttributes.length; ++i) {
-      validDocIndexToOriginalIndex.set(i, originalDocIndex.get(docAttributes[i]));
-    }
+  }
 
-    // Make sure validation errors are in the same order as the
-    // original documents, so if both doc1 and doc2 both fail validation,
-    // `Model.insertMany([doc1, doc2])` will always have doc1's validation
-    // error before doc2's. Re: gh-12791.
-    if (validationErrors.length > 0) {
-      validationErrors.sort((err1, err2) => {
-        return validationErrorsToOriginalOrder.get(err1) - validationErrorsToOriginalOrder.get(err2);
-      });
+  // Quickly escape while there aren't any valid docAttributes
+  if (docAttributes.length === 0) {
+    if (throwOnValidationError) {
+      throw new MongooseBulkWriteError(
+        validationErrors,
+        results,
+        null,
+        'insertMany'
+      );
     }
-
-    // Quickly escape while there aren't any valid docAttributes
-    if (docAttributes.length === 0) {
-      if (throwOnValidationError) {
-        return callback(new MongooseBulkWriteError(
-          validationErrors,
-          results,
-          null,
-          'insertMany'
-        ));
-      }
-      if (rawResult) {
-        const res = {
-          acknowledged: true,
-          insertedCount: 0,
-          insertedIds: {}
-        };
-        decorateBulkWriteResult(res, validationErrors, validationErrors);
-        return callback(null, res);
-      }
-      callback(null, []);
-      return;
+    if (rawResult) {
+      const res = {
+        acknowledged: true,
+        insertedCount: 0,
+        insertedIds: {}
+      };
+      decorateBulkWriteResult(res, validationErrors, validationErrors);
+      return res;
     }
-    const docObjects = lean ? docAttributes : docAttributes.map(function(doc) {
-      if (doc.$__schema.options.versionKey) {
-        doc[doc.$__schema.options.versionKey] = 0;
-      }
-      const shouldSetTimestamps = (!options || options.timestamps !== false) && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
-      if (shouldSetTimestamps) {
-        doc.initializeTimestamps();
-      }
-      if (doc.$__hasOnlyPrimitiveValues()) {
-        return doc.$__toObjectShallow();
-      }
-      return doc.toObject(internalToObjectOptions);
-    });
-
-    _this.$__collection.insertMany(docObjects, options).then(
-      res => {
-        if (!lean) {
-          for (const attribute of docAttributes) {
-            attribute.$__reset();
-            _setIsNew(attribute, false);
-          }
-        }
+    return [];
+  }
+  const docObjects = lean ? docAttributes : docAttributes.map(function(doc) {
+    if (doc.$__schema.options.versionKey) {
+      doc[doc.$__schema.options.versionKey] = 0;
+    }
+    const shouldSetTimestamps = (!options || options.timestamps !== false) && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
+    if (shouldSetTimestamps) {
+      doc.initializeTimestamps();
+    }
+    if (doc.$__hasOnlyPrimitiveValues()) {
+      return doc.$__toObjectShallow();
+    }
+    return doc.toObject(internalToObjectOptions);
+  });
 
-        if (ordered === false && throwOnValidationError && validationErrors.length > 0) {
-          for (let i = 0; i < results.length; ++i) {
-            if (results[i] === void 0) {
-              results[i] = docs[i];
-            }
-          }
-          return callback(new MongooseBulkWriteError(
-            validationErrors,
-            results,
-            res,
-            'insertMany'
-          ));
-        }
+  let res;
+  try {
+    res = await this.$__collection.insertMany(docObjects, options);
+  } catch (error) {
+    // `writeErrors` is a property reported by the MongoDB driver,
+    // just not if there's only 1 error.
+    if (error.writeErrors == null &&
+        (error.result && error.result.result && error.result.result.writeErrors) != null) {
+      error.writeErrors = error.result.result.writeErrors;
+    }
 
-        if (rawResult) {
-          if (ordered === false) {
-            for (let i = 0; i < results.length; ++i) {
-              if (results[i] === void 0) {
-                results[i] = docs[i];
-              }
-            }
+    // `insertedDocs` is a Mongoose-specific property
+    const hasWriteErrors = error && error.writeErrors;
+    const erroredIndexes = new Set((error && error.writeErrors || []).map(err => err.index));
 
-            // Decorate with mongoose validation errors in case of unordered,
-            // because then still do `insertMany()`
-            decorateBulkWriteResult(res, validationErrors, results);
-          }
-          return callback(null, res);
+    if (error.writeErrors != null) {
+      for (let i = 0; i < error.writeErrors.length; ++i) {
+        const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
+        error.writeErrors[i] = { ...error.writeErrors[i], index: originalIndex };
+        if (!ordered) {
+          results[originalIndex] = error.writeErrors[i];
         }
+      }
+    }
 
-        if (options.populate != null) {
-          return _this.populate(docAttributes, options.populate).then(
-            docs => { callback(null, docs); },
-            err => {
-              if (err != null) {
-                err.insertedDocs = docAttributes;
-              }
-              throw err;
-            }
-          );
+    if (!ordered) {
+      for (let i = 0; i < results.length; ++i) {
+        if (results[i] === void 0) {
+          results[i] = docs[i];
         }
+      }
 
-        callback(null, docAttributes);
-      },
-      error => {
-        // `writeErrors` is a property reported by the MongoDB driver,
-        // just not if there's only 1 error.
-        if (error.writeErrors == null &&
-            (error.result && error.result.result && error.result.result.writeErrors) != null) {
-          error.writeErrors = error.result.result.writeErrors;
-        }
+      error.results = results;
+    }
 
-        // `insertedDocs` is a Mongoose-specific property
-        const hasWriteErrors = error && error.writeErrors;
-        const erroredIndexes = new Set((error && error.writeErrors || []).map(err => err.index));
+    let firstErroredIndex = -1;
+    error.insertedDocs = docAttributes.
+      filter((doc, i) => {
+        const isErrored = !hasWriteErrors || erroredIndexes.has(i);
 
-        if (error.writeErrors != null) {
-          for (let i = 0; i < error.writeErrors.length; ++i) {
-            const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
-            error.writeErrors[i] = { ...error.writeErrors[i], index: originalIndex };
-            if (!ordered) {
-              results[originalIndex] = error.writeErrors[i];
-            }
+        if (ordered) {
+          if (firstErroredIndex > -1) {
+            return i < firstErroredIndex;
           }
-        }
 
-        if (!ordered) {
-          for (let i = 0; i < results.length; ++i) {
-            if (results[i] === void 0) {
-              results[i] = docs[i];
-            }
+          if (isErrored) {
+            firstErroredIndex = i;
           }
+        }
 
-          error.results = results;
+        return !isErrored;
+      }).
+      map(function setIsNewForInsertedDoc(doc) {
+        if (lean) {
+          return doc;
         }
+        doc.$__reset();
+        _setIsNew(doc, false);
+        return doc;
+      });
 
-        let firstErroredIndex = -1;
-        error.insertedDocs = docAttributes.
-          filter((doc, i) => {
-            const isErrored = !hasWriteErrors || erroredIndexes.has(i);
+    if (rawResult && ordered === false) {
+      decorateBulkWriteResult(error, validationErrors, results);
+    }
 
-            if (ordered) {
-              if (firstErroredIndex > -1) {
-                return i < firstErroredIndex;
-              }
+    await this._middleware.execPost('insertMany', this, [arr], { error });
+  }
 
-              if (isErrored) {
-                firstErroredIndex = i;
-              }
-            }
+  if (!lean) {
+    for (const attribute of docAttributes) {
+      attribute.$__reset();
+      _setIsNew(attribute, false);
+    }
+  }
 
-            return !isErrored;
-          }).
-          map(function setIsNewForInsertedDoc(doc) {
-            if (lean) {
-              return doc;
-            }
-            doc.$__reset();
-            _setIsNew(doc, false);
-            return doc;
-          });
+  if (ordered === false && throwOnValidationError && validationErrors.length > 0) {
+    for (let i = 0; i < results.length; ++i) {
+      if (results[i] === void 0) {
+        results[i] = docs[i];
+      }
+    }
+    throw new MongooseBulkWriteError(
+      validationErrors,
+      results,
+      res,
+      'insertMany'
+    );
+  }
 
-        if (rawResult && ordered === false) {
-          decorateBulkWriteResult(error, validationErrors, results);
+  if (rawResult) {
+    if (ordered === false) {
+      for (let i = 0; i < results.length; ++i) {
+        if (results[i] === void 0) {
+          results[i] = docs[i];
         }
+      }
 
-        callback(error, null);
+      // Decorate with mongoose validation errors in case of unordered,
+      // because then still do `insertMany()`
+      decorateBulkWriteResult(res, validationErrors, results);
+    }
+    return res;
+  }
+
+  if (options.populate != null) {
+    return this.populate(docAttributes, options.populate).catch(err => {
+      if (err != null) {
+        err.insertedDocs = docAttributes;
       }
-    );
-  });
+      throw err;
+    });
+  }
+
+  return await this._middleware.execPost('insertMany', this, [docAttributes]).then(res => res[0]);
 };
 
 /*!
@@ -3401,20 +3286,15 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
   }
   options = options || {};
 
-  const shouldSkip = await new Promise((resolve, reject) => {
-    this.hooks.execPre('bulkWrite', this, [ops, options], (err) => {
-      if (err != null) {
-        if (err instanceof Kareem.skipWrappedFunction) {
-          return resolve(err);
-        }
-        return reject(err);
-      }
-      resolve();
-    });
+  [ops, options] = await this.hooks.execPre('bulkWrite', this, [ops, options]).catch(err => {
+    if (err instanceof Kareem.skipWrappedFunction) {
+      return [err];
+    }
+    throw err;
   });
 
-  if (shouldSkip) {
-    return shouldSkip.args[0];
+  if (ops instanceof Kareem.skipWrappedFunction) {
+    return ops.args[0];
   }
 
   const ordered = options.ordered == null ? true : options.ordered;
@@ -3448,15 +3328,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     try {
       res = await this.$__collection.bulkWrite(ops, options);
     } catch (error) {
-      await new Promise((resolve, reject) => {
-        const _opts = { error: error };
-        this.hooks.execPost('bulkWrite', this, [null], _opts, (err) => {
-          if (err != null) {
-            return reject(err);
-          }
-          resolve();
-        });
-      });
+      await this.hooks.execPost('bulkWrite', this, [null], { error });
     }
   } else {
     let validOpIndexes = [];
@@ -3525,15 +3397,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
         decorateBulkWriteResult(error, validationErrors, results);
       }
 
-      await new Promise((resolve, reject) => {
-        const _opts = { error: error };
-        this.hooks.execPost('bulkWrite', this, [null], _opts, (err) => {
-          if (err != null) {
-            return reject(err);
-          }
-          resolve();
-        });
-      });
+      await this.hooks.execPost('bulkWrite', this, [null], { error });
     }
 
     if (validationErrors.length > 0) {
@@ -3550,14 +3414,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     }
   }
 
-  await new Promise((resolve, reject) => {
-    this.hooks.execPost('bulkWrite', this, [res], (err) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve();
-    });
-  });
+  await this.hooks.execPost('bulkWrite', this, [res]);
 
   return res;
 };
@@ -3647,34 +3504,20 @@ Model.bulkSave = async function bulkSave(documents, options) {
   return bulkWriteResult;
 };
 
-function buildPreSavePromise(document, options) {
-  return new Promise((resolve, reject) => {
-    document.schema.s.hooks.execPre('save', document, [options], (err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve();
-    });
-  });
+async function buildPreSavePromise(document, options) {
+  const [newOptions] = await document.schema.s.hooks.execPre('save', document, [options]);
+  if (newOptions !== options) {
+    throw new Error('Cannot overwrite options in pre("save") hook on bulkSave()');
+  }
 }
 
-function handleSuccessfulWrite(document) {
-  return new Promise((resolve, reject) => {
-    if (document.$isNew) {
-      _setIsNew(document, false);
-    }
-
-    document.$__reset();
-    document.schema.s.hooks.execPost('save', document, [document], {}, (err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve();
-    });
+async function handleSuccessfulWrite(document) {
+  if (document.$isNew) {
+    _setIsNew(document, false);
+  }
 
-  });
+  document.$__reset();
+  return document.schema.s.hooks.execPost('save', document, [document]);
 }
 
 /**
@@ -3847,7 +3690,7 @@ Model.castObject = function castObject(obj, options) {
           }
         } else {
           cur[pieces[pieces.length - 1]] = [
-            Model.castObject.call(schemaType.caster, val)
+            Model.castObject.call(schemaType.Constructor, val)
           ];
         }
 
@@ -3856,7 +3699,7 @@ Model.castObject = function castObject(obj, options) {
     }
     if (schemaType.$isSingleNested || schemaType.$isMongooseDocumentArrayElement) {
       try {
-        val = Model.castObject.call(schemaType.caster, val);
+        val = Model.castObject.call(schemaType.Constructor, val);
       } catch (err) {
         if (!options.ignoreCastErrors) {
           error = error || new ValidationError();
@@ -4322,51 +4165,34 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
     }
   }
 
-  let remaining = paths.size;
-
-  return new Promise((resolve, reject) => {
-    if (remaining === 0) {
-      return settle();
+  const promises = [];
+  for (const path of paths) {
+    const schemaType = schema.path(path);
+    if (schemaType == null) {
+      continue;
     }
 
-    for (const path of paths) {
-      const schemaType = schema.path(path);
-      if (schemaType == null) {
-        _checkDone();
-        continue;
-      }
-
-      const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
-      let cur = obj;
-      for (let i = 0; i < pieces.length - 1; ++i) {
-        cur = cur[pieces[i]];
-      }
-
-      const val = get(obj, path, void 0);
-
-      schemaType.doValidate(val, err => {
-        if (err) {
-          error = error || new ValidationError();
-          error.addError(path, err);
-        }
-        _checkDone();
-      }, context, { path: path });
+    const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
+    let cur = obj;
+    for (let i = 0; i < pieces.length - 1; ++i) {
+      cur = cur[pieces[i]];
     }
 
-    function settle() {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(obj);
-      }
-    }
+    const val = get(obj, path, void 0);
+    promises.push(
+      schemaType.doValidate(val, context, { path: path }).catch(err => {
+        error = error || new ValidationError();
+        error.addError(path, err);
+      })
+    );
+  }
 
-    function _checkDone() {
-      if (--remaining <= 0) {
-        return settle();
-      }
-    }
-  });
+  await Promise.all(promises);
+  if (error != null) {
+    throw error;
+  }
+
+  return obj;
 };
 
 /**
@@ -4736,14 +4562,7 @@ function _assign(model, vals, mod, assignmentOpts) {
           if (__val instanceof Document) {
             __val = __val._doc._id;
           }
-          if (__val?.constructor?.name === 'Binary' && __val.sub_type === 4 && typeof __val.toUUID === 'function') {
-            // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
-            key = String(__val.toUUID());
-          } else if (__val?.constructor?.name === 'Buffer' && __val._subtype === 4 && typeof __val.toUUID === 'function') {
-            key = String(__val.toUUID());
-          } else {
-            key = String(__val);
-          }
+          key = String(__val);
           if (rawDocs[key]) {
             if (Array.isArray(rawDocs[key])) {
               rawDocs[key].push(val);
@@ -4766,14 +4585,7 @@ function _assign(model, vals, mod, assignmentOpts) {
         if (_val instanceof Document) {
           _val = _val._doc._id;
         }
-        if (_val?.constructor?.name === 'Binary' && _val.sub_type === 4 && typeof _val.toUUID === 'function') {
-          // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
-          key = String(_val.toUUID());
-        } else if (_val?.constructor?.name === 'Buffer' && _val._subtype === 4 && typeof _val.toUUID === 'function') {
-          key = String(_val.toUUID());
-        } else {
-          key = String(_val);
-        }
+        key = String(_val);
         if (rawDocs[key]) {
           if (Array.isArray(rawDocs[key])) {
             rawDocs[key].push(val);