feat(document+model): pass options to pre('deleteOne') and update+options to pre('updateOne') hooks

lib/document.js

@@ -842,7 +842,7 @@ function init(self, obj, doc, opts, prefix) {
  *  - same as in [Model.updateOne](https://mongoosejs.com/docs/api/model.html#Model.updateOne)
  *
  * @see Model.updateOne https://mongoosejs.com/docs/api/model.html#Model.updateOne
- * @param {Object} doc
+ * @param {Object} update
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and the [Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
@@ -853,22 +853,24 @@ function init(self, obj, doc, opts, prefix) {
  * @instance
  */
 
-Document.prototype.updateOne = function updateOne(doc, options, callback) {
-  const query = this.constructor.updateOne({ _id: this._doc._id }, doc, options);
+Document.prototype.updateOne = function updateOne(update, options, callback) {
+  const query = this.constructor.updateOne();
   const self = this;
   query.pre(function queryPreUpdateOne(cb) {
-    self.constructor._middleware.execPre('updateOne', self, [self], cb);
+    self.constructor._middleware.execPre('updateOne', self, [self, update, options], (err, res) => {
+      this.updateOne({ _id: self._doc._id }, update, options);
+      if (self.$session() != null) {
+        if (!('session' in query.options)) {
+          query.options.session = self.$session();
+        }
+      }
+      return cb(err, res);
+    });
   });
   query.post(function queryPostUpdateOne(cb) {
     self.constructor._middleware.execPost('updateOne', self, [self], {}, cb);
   });
 
-  if (this.$session() != null) {
-    if (!('session' in query.options)) {
-      query.options.session = this.$session();
-    }
-  }
-
   if (callback != null) {
     return query.exec(callback);
   }

lib/model.js

@@ -789,7 +789,7 @@ Model.prototype.deleteOne = function deleteOne(options) {
   if (where instanceof Error) {
     throw where;
   }
-  const query = self.constructor.deleteOne(where, options);
+  const query = self.constructor.deleteOne();
 
   if (this.$session() != null) {
     if (!('session' in query.options)) {
@@ -799,7 +799,8 @@ Model.prototype.deleteOne = function deleteOne(options) {
 
   query.pre(async function queryPreDeleteOne() {
     await new Promise((resolve, reject) => {
-      self.constructor._middleware.execPre('deleteOne', self, [self], err => {
+      self.constructor._middleware.execPre('deleteOne', self, [self, options], err => {
+        query.deleteOne(where, options);
         if (err) reject(err);
         else resolve();
       });
@@ -812,7 +813,7 @@ Model.prototype.deleteOne = function deleteOne(options) {
   });
   query.pre(function callSubdocPreHooks(cb) {
     each(self.$getAllSubdocs(), (subdoc, cb) => {
-      subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc], cb);
+      subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc, options], cb);
     }, cb);
   });
   query.pre(function skipIfAlreadyDeleted(cb) {

test/document.test.js

@@ -6850,9 +6850,21 @@ describe('document', function() {
     let docRegexCount = 0;
     let docPostRegexCount = 0;
 
-    schema.pre('updateOne', () => ++queryCount);
-    schema.pre('updateOne', { document: true, query: false }, () => ++docCount);
-    schema.post('updateOne', { document: true, query: false }, () => ++docPostCount);
+    schema.pre('updateOne', { document: false, query: true }, function() {
+      ++queryCount;
+      assert.strictEqual(this.options.testOption, 'newValue');
+    });
+    schema.pre('updateOne', { document: true, query: false }, (next, doc, update, opts) => {
+      assert.strictEqual(opts.testOption, 'value');
+      assert.deepStrictEqual(update, { name: 'test2' });
+      opts.testOption = 'newValue';
+      ++docCount;
+      next();
+    });
+    schema.post('updateOne', { document: true, query: false }, () => {
+      ++docPostCount;
+    });
+
 
     schema.pre(/^updateOne$/, { document: true, query: false }, () => ++docRegexCount);
     schema.post(/^updateOne$/, { document: true, query: false }, () => ++docPostRegexCount);
@@ -6874,7 +6886,7 @@ describe('document', function() {
     assert.equal(docRegexCount, 0);
     assert.equal(docPostRegexCount, 0);
 
-    await doc.updateOne({ name: 'test2' });
+    await doc.updateOne({ name: 'test2' }, { testOption: 'value' });
 
     assert.equal(queryCount, 1);
     assert.equal(docCount, 1);

test/model.middleware.test.js

@@ -352,8 +352,10 @@ describe('model middleware', function() {
       next();
     });
 
-    schema.pre('deleteOne', { document: true, query: false }, function(next) {
+    schema.pre('deleteOne', { document: true, query: false }, function(next, doc, opts) {
       ++preRemove;
+      assert.strictEqual(opts.testOption, 'value');
+      opts.testOption = 'something else';
       next();
     });
 
@@ -377,7 +379,7 @@ describe('model middleware', function() {
     assert.equal(preRemove, 0);
     assert.equal(postRemove, 0);
 
-    await test.deleteOne();
+    await test.deleteOne({ testOption: 'value' });
     assert.equal(preValidate, 1);
     assert.equal(postValidate, 1);
     assert.equal(preRemove, 1);

test/types/schema.test.ts

@@ -1243,7 +1243,8 @@ function gh13633() {
   schema.pre('updateOne', { document: true, query: false }, function(next) {
   });
 
-  schema.pre('updateOne', { document: true, query: false }, function(next, options) {
+  schema.pre('updateOne', { document: true, query: false }, function(next, doc, update, options) {
+    expectType<Record<string, any> | undefined>(update);
     expectType<Record<string, any> | undefined>(options);
   });
 

types/index.d.ts

@@ -468,19 +468,29 @@ declare module 'mongoose' {
     pre<T = never>(method: MongooseDistinctDocumentMiddleware | MongooseDistinctDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: false, query: boolean }, fn: PreMiddlewareFunction<T>): this;
     // this = Union of Document and Query, could be called with any of them
     pre<T = THydratedDocumentType | Query<any, any>>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
       options: SchemaPreOptions & { document: true, query: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType | Query<any, any>>(
+      method: 'deleteOne' | RegExp,
+      options: SchemaPreOptions & { document: true, query: true },
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType, U = RawDocType>(method: 'init', fn: (this: T, doc: U) => void): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
+      options: SchemaPreOptions & { document: true },
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType>(
+      method: 'deleteOne' | RegExp,
       options: SchemaPreOptions & { document: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     pre<T = THydratedDocumentType>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: true, query: false }, fn: PreMiddlewareFunction<T>): this;
     // this = Query

types/middlewares.d.ts

@@ -39,6 +39,19 @@ declare module 'mongoose' {
     next: CallbackWithoutResultAndOptionalError,
     opts?: Record<string, any>
   ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreDeleteOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    next: CallbackWithoutResultAndOptionalError,
+    doc: ThisType,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreUpdateOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    next: CallbackWithoutResultAndOptionalError,
+    doc: ThisType,
+    update?: Record<string, any>,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
   type PreSaveMiddlewareFunction<ThisType = any> = (
     this: ThisType,
     next: CallbackWithoutResultAndOptionalError,