ts-patch-mongoose 2.3.0 → 2.4.0

package/dist/esm/types/models/History.d.ts

@@ -24,6 +24,12 @@
 /// <reference types="mongoose/types/inferschematype" />
 import { Schema } from 'mongoose';
 import type IHistory from '../interfaces/IHistory';
-declare const History: import("mongoose").Model<IHistory, {}, {}, {}, Schema<IHistory, import("mongoose").Model<IHistory, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IHistory>>;
+declare const History: import("mongoose").Model<IHistory, {}, {}, {}, import("mongoose").Document<unknown, {}, IHistory> & IHistory & {
+    _id: import("mongoose").Types.ObjectId;
+}, Schema<IHistory, import("mongoose").Model<IHistory, any, any, any, import("mongoose").Document<unknown, any, IHistory> & IHistory & {
+    _id: import("mongoose").Types.ObjectId;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IHistory, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IHistory>> & import("mongoose").FlatRecord<IHistory> & {
+    _id: import("mongoose").Types.ObjectId;
+}>>;
 export default History;
 //# sourceMappingURL=History.d.ts.map

package/dist/esm/types/models/History.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"History.d.ts","sourceRoot":"","sources":["../../../../src/models/History.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,MAAM,EAAS,MAAM,UAAU,CAAA;AAExC,OAAO,KAAK,QAAQ,MAAM,wBAAwB,CAAA;AA4ClD,QAAA,MAAM,OAAO,6LAA6C,CAAA;AAE1D,eAAe,OAAO,CAAA"}
+{"version":3,"file":"History.d.ts","sourceRoot":"","sources":["../../../../src/models/History.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,MAAM,EAAS,MAAM,UAAU,CAAA;AAExC,OAAO,KAAK,QAAQ,MAAM,wBAAwB,CAAA;AA4ClD,QAAA,MAAM,OAAO;;;;;;GAA6C,CAAA;AAE1D,eAAe,OAAO,CAAA"}

package/dist/esm/types/plugin.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 /// <reference types="mongoose/types/aggregate" />
 /// <reference types="mongoose/types/callback" />
 /// <reference types="mongoose/types/collection" />
@@ -25,6 +26,7 @@
 import type { Model, Schema } from 'mongoose';
 import type IPluginOptions from './interfaces/IPluginOptions';
 export declare const patchEventEmitter: {
+    [EventEmitter.captureRejectionSymbol]?(error: Error, event: string, ...args: any[]): void;
     addListener(eventName: string | symbol, listener: (...args: any[]) => void): any;
     on(eventName: string | symbol, listener: (...args: any[]) => void): any;
     once(eventName: string | symbol, listener: (...args: any[]) => void): any;
@@ -41,5 +43,5 @@ export declare const patchEventEmitter: {
     prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): any;
     eventNames(): (string | symbol)[];
 };
-export declare const patchHistoryPlugin: <T>(schema: Schema<T, Model<T, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, import("mongoose").ObtainDocumentType<any, T, import("mongoose").DefaultSchemaOptions>>, opts: IPluginOptions<T>) => void;
+export declare const patchHistoryPlugin: <T>(schema: Schema<T, Model<T, any, any, any, import("mongoose").IfAny<T, any, import("mongoose").Document<unknown, any, T> & import("mongoose").Require_id<T>>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>, import("mongoose").IfAny<import("mongoose").FlatRecord<import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>>, any, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>>> & import("mongoose").Require_id<import("mongoose").FlatRecord<import("mongoose").ObtainDocumentType<any, T, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>>>>>>, opts: IPluginOptions<T>) => void;
 //# sourceMappingURL=plugin.d.ts.map

package/dist/esm/types/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAGA,OAAO,KAAK,EAAoB,KAAK,EAAyC,MAAM,EAA+D,MAAM,UAAU,CAAA;AAEnK,OAAO,KAAK,cAAc,MAAM,6BAA6B,CAAA;AA0E7D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;CAAK,CAAA;AAQnC,eAAO,MAAM,kBAAkB,oOAAoE,IA4IlG,CAAA"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/plugin.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAWA,OAAO,KAAK,EAAoB,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAC/D,OAAO,KAAK,cAAc,MAAM,6BAA6B,CAAA;AAQ7D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;CAAK,CAAA;AAQnC,eAAO,MAAM,kBAAkB,y8BAAoE,IA+ClG,CAAA"}

package/dist/esm/types/version.d.ts

@@ -1,3 +1,4 @@
+export declare const isMongooseLessThan8: boolean;
 export declare const isMongooseLessThan7: boolean;
 export declare const isMongoose6: boolean;
 //# sourceMappingURL=version.d.ts.map

package/dist/esm/types/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/version.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,SAAoC,CAAA;AACpE,eAAO,MAAM,WAAW,SAAmC,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/version.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,SAAoC,CAAA;AACpE,eAAO,MAAM,mBAAmB,SAAoC,CAAA;AACpE,eAAO,MAAM,WAAW,SAAmC,CAAA"}

package/dist/esm/version.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMongoose6 = exports.isMongooseLessThan7 = void 0;
+exports.isMongoose6 = exports.isMongooseLessThan7 = exports.isMongooseLessThan8 = void 0;
 const tslib_1 = require("tslib");
 const semver_1 = require("semver");
 const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+exports.isMongooseLessThan8 = (0, semver_1.satisfies)(mongoose_1.default.version, '<8');
 exports.isMongooseLessThan7 = (0, semver_1.satisfies)(mongoose_1.default.version, '<7');
 exports.isMongoose6 = (0, semver_1.satisfies)(mongoose_1.default.version, '6');
 if (exports.isMongoose6) {

package/dist/esm/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";;;;AAAA,mCAAkC;AAClC,gEAA+B;AAElB,QAAA,mBAAmB,GAAG,IAAA,kBAAS,EAAC,kBAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;AACvD,QAAA,WAAW,GAAG,IAAA,kBAAS,EAAC,kBAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;AAE3D,IAAI,mBAAW,EAAE;IACf,kBAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;CACnC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";;;;AAAA,mCAAkC;AAClC,gEAA+B;AAElB,QAAA,mBAAmB,GAAG,IAAA,kBAAS,EAAC,kBAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;AACvD,QAAA,mBAAmB,GAAG,IAAA,kBAAS,EAAC,kBAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;AACvD,QAAA,WAAW,GAAG,IAAA,kBAAS,EAAC,kBAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;AAE3D,IAAI,mBAAW,EAAE;IACf,kBAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,KAAK,CAAC,CAAA;CACnC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-patch-mongoose",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Patch history & events for mongoose models",
   "author": "Alex Eagle",
   "license": "MIT",
@@ -85,22 +85,22 @@
   "devDependencies": {
     "@shelf/jest-mongodb": "4.1.7",
     "@swc/cli": "0.1.62",
-    "@swc/core": "1.3.91",
-    "@swc/helpers": "0.5.2",
+    "@swc/core": "1.3.96",
+    "@swc/helpers": "0.5.3",
     "@swc/jest": "0.2.29",
     "@swc/register": "0.1.10",
-    "@types/jest": "29.5.5",
-    "@types/lodash": "4.14.199",
-    "@types/node": "18",
-    "@typescript-eslint/eslint-plugin": "6.7.3",
-    "@typescript-eslint/parser": "6.7.3",
-    "eslint": "8.50.0",
-    "eslint-plugin-jest": "27.4.2",
+    "@types/jest": "29.5.7",
+    "@types/lodash": "4.14.200",
+    "@types/node": "20",
+    "@typescript-eslint/eslint-plugin": "6.9.1",
+    "@typescript-eslint/parser": "6.9.1",
+    "eslint": "8.53.0",
+    "eslint-plugin-jest": "27.6.0",
     "eslint-plugin-jest-formatting": "3.1.0",
-    "eslint-plugin-sonarjs": "0.21.0",
+    "eslint-plugin-sonarjs": "0.23.0",
     "jest": "29.7.0",
     "merge": "2.1.1",
-    "mongoose": "6.12.0",
+    "mongoose": "latest",
     "open-cli": "7.2.0",
     "ts-node": "10.9.1",
     "typescript": "5.2.2"

package/src/helpers.ts

@@ -0,0 +1,10 @@
+import type { QueryOptions, ToObjectOptions } from 'mongoose'
+
+export const isHookIgnored = <T>(options: QueryOptions<T>): boolean => {
+  return options.ignoreHook === true || (options.ignoreEvent === true && options.ignorePatchHistory === true)
+}
+
+export const toObjectOptions: ToObjectOptions = {
+  depopulate: true,
+  virtuals: false
+}

package/src/hooks/delete-hooks.ts

@@ -0,0 +1,59 @@
+import _ from 'lodash'
+
+import { deletePatch } from '../patch'
+import { isHookIgnored } from '../helpers'
+
+import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema } from 'mongoose'
+import type IPluginOptions from '../interfaces/IPluginOptions'
+import type IHookContext from '../interfaces/IHookContext'
+
+const deleteMethods = [
+  'remove',
+  'findOneAndDelete',
+  'findOneAndRemove',
+  'findByIdAndDelete',
+  'findByIdAndRemove',
+  'deleteOne',
+  'deleteMany'
+]
+
+export const deleteHooksInitialize = <T>(schema: Schema<T>, opts: IPluginOptions<T>): void => {
+  schema.pre(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: IHookContext<T>) {
+    const options = this.getOptions()
+    if (isHookIgnored(options)) return
+
+    const model = this.model as Model<T>
+    const filter = this.getFilter()
+
+    this._context = {
+      op: this.op,
+      modelName: opts.modelName ?? this.model.modelName,
+      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      ignoreEvent: options.ignoreEvent as boolean,
+      ignorePatchHistory: options.ignorePatchHistory as boolean
+    }
+
+    if (['remove', 'deleteMany'].includes(this._context.op) && !options.single) {
+      const docs = await model.find(filter).lean().exec()
+      if (!_.isEmpty(docs)) {
+        this._context.deletedDocs = docs as HydratedDocument<T>[]
+      }
+    } else {
+      const doc = await model.findOne(filter).lean().exec()
+      if (!_.isEmpty(doc)) {
+        this._context.deletedDocs = [doc] as HydratedDocument<T>[]
+      }
+    }
+
+    if (opts.preDelete && _.isArray(this._context.deletedDocs) && !_.isEmpty(this._context.deletedDocs)) {
+      await opts.preDelete(this._context.deletedDocs)
+    }
+  })
+
+  schema.post(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: IHookContext<T>) {
+    const options = this.getOptions()
+    if (isHookIgnored(options)) return
+
+    await deletePatch(opts, this._context)
+  })
+}

package/src/hooks/save-hooks.ts

@@ -0,0 +1,29 @@
+import { createPatch, updatePatch } from '../patch'
+import { toObjectOptions } from '../helpers'
+
+import type { HydratedDocument, Model, Schema } from 'mongoose'
+import type IPluginOptions from '../interfaces/IPluginOptions'
+import type IContext from '../interfaces/IContext'
+
+export const saveHooksInitialize = <T>(schema: Schema<T>, opts: IPluginOptions<T>): void => {
+  schema.pre('save', async function () {
+    const current = this.toObject(toObjectOptions) as HydratedDocument<T>
+    const model = this.constructor as Model<T>
+
+    const context: IContext<T> = {
+      op: this.isNew ? 'create' : 'update',
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
+      createdDocs: [current]
+    }
+
+    if (this.isNew) {
+      await createPatch(opts, context)
+    } else {
+      const original = await model.findById(current._id).lean().exec()
+      if (original) {
+        await updatePatch(opts, context, current, original as HydratedDocument<T>)
+      }
+    }
+  })
+}

package/src/hooks/update-hooks.ts

@@ -0,0 +1,100 @@
+import _ from 'lodash'
+import { assign } from 'power-assign'
+
+import { createPatch, updatePatch } from '../patch'
+import { isHookIgnored } from '../helpers'
+
+import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema, UpdateQuery, UpdateWithAggregationPipeline } from 'mongoose'
+import type IPluginOptions from '../interfaces/IPluginOptions'
+import type IHookContext from '../interfaces/IHookContext'
+
+const updateMethods = [
+  'update',
+  'updateOne',
+  'replaceOne',
+  'updateMany',
+  'findOneAndUpdate',
+  'findOneAndReplace',
+  'findByIdAndUpdate'
+]
+
+export const assignUpdate = <T>(document: HydratedDocument<T>, update: UpdateQuery<T>, commands: Record<string, unknown>[]): HydratedDocument<T> => {
+  let updated = assign(document, update)
+  _.forEach(commands, (command) => {
+    try {
+      updated = assign(updated, command)
+    } catch {
+      // we catch assign keys that are not implemented
+    }
+  })
+
+  return updated
+}
+
+export const splitUpdateAndCommands = <T>(updateQuery: UpdateWithAggregationPipeline | UpdateQuery<T> | null): { update: UpdateQuery<T>, commands: Record<string, unknown>[] } => {
+  let update: UpdateQuery<T> = {}
+  const commands: Record<string, unknown>[] = []
+
+  if (!_.isEmpty(updateQuery) && !_.isArray(updateQuery) && _.isObjectLike(updateQuery)) {
+    update = _.cloneDeep(updateQuery)
+    const keys = _.keys(update).filter((key) => key.startsWith('$'))
+    if (!_.isEmpty(keys)) {
+      _.forEach(keys, (key) => {
+        commands.push({ [key]: update[key] as unknown })
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete update[key]
+      })
+    }
+  }
+
+  return { update, commands }
+}
+
+export const updateHooksInitialize = <T>(schema: Schema<T>, opts: IPluginOptions<T>): void => {
+  schema.pre(updateMethods as MongooseQueryMiddleware[], async function (this: IHookContext<T>) {
+    const options = this.getOptions()
+    if (isHookIgnored(options)) return
+
+    const model = this.model as Model<T>
+    const filter = this.getFilter()
+    const count = await this.model.countDocuments(filter).exec()
+
+    this._context = {
+      op: this.op,
+      modelName: opts.modelName ?? this.model.modelName,
+      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      isNew: options.upsert && count === 0,
+      ignoreEvent: options.ignoreEvent as boolean,
+      ignorePatchHistory: options.ignorePatchHistory as boolean
+    }
+
+    const updateQuery = this.getUpdate()
+    const { update, commands } = splitUpdateAndCommands(updateQuery)
+
+    const cursor = model.find(filter).lean().cursor()
+    await cursor.eachAsync(async (doc: HydratedDocument<T>) => {
+      await updatePatch(opts, this._context, assignUpdate(doc, update, commands), doc)
+    })
+  })
+
+  schema.post(updateMethods as MongooseQueryMiddleware[], async function (this: IHookContext<T>) {
+    const options = this.getOptions()
+    if (isHookIgnored(options)) return
+
+    if (!this._context.isNew) return
+
+    const model = this.model as Model<T>
+    const updateQuery = this.getUpdate()
+    const { update, commands } = splitUpdateAndCommands(updateQuery)
+
+    const filter = assignUpdate({} as HydratedDocument<T>, update, commands)
+    if (!_.isEmpty(filter)) {
+      const current = await model.findOne(update).lean().exec()
+      if (current) {
+        this._context.createdDocs = [current] as HydratedDocument<T>[]
+
+        await createPatch(opts, this._context)
+      }
+    }
+  })
+}

package/src/plugin.ts

@@ -1,79 +1,20 @@
 import _ from 'lodash'
-import { assign } from 'power-assign'
+import em from './em'
+
+import { createPatch, deletePatch } from './patch'
+import { isMongooseLessThan7, isMongooseLessThan8 } from './version'
+import { toObjectOptions } from './helpers'
 
-import type { HydratedDocument, Model, MongooseQueryMiddleware, QueryOptions, Schema, ToObjectOptions, UpdateQuery, UpdateWithAggregationPipeline } from 'mongoose'
+import { saveHooksInitialize } from './hooks/save-hooks'
+import { updateHooksInitialize } from './hooks/update-hooks'
+import { deleteHooksInitialize } from './hooks/delete-hooks'
 
+import type { HydratedDocument, Model, Schema } from 'mongoose'
 import type IPluginOptions from './interfaces/IPluginOptions'
 import type IContext from './interfaces/IContext'
-import type IHookContext from './interfaces/IHookContext'
-
-import { createPatch, updatePatch, deletePatch } from './patch'
-import { isMongooseLessThan7 } from './version'
-import em from './em'
 
 const remove = isMongooseLessThan7 ? 'remove' : 'deleteOne'
 
-const toObjectOptions: ToObjectOptions = {
-  depopulate: true,
-  virtuals: false
-}
-
-const updateMethods = [
-  'update',
-  'updateOne',
-  'replaceOne',
-  'updateMany',
-  'findOneAndUpdate',
-  'findOneAndReplace',
-  'findByIdAndUpdate'
-]
-
-const deleteMethods = [
-  'remove',
-  'findOneAndDelete',
-  'findOneAndRemove',
-  'findByIdAndDelete',
-  'findByIdAndRemove',
-  'deleteOne',
-  'deleteMany'
-]
-
-function isHookIgnored<T> (options: QueryOptions<T>): boolean {
-  return options.ignoreHook === true || (options.ignoreEvent === true && options.ignorePatchHistory === true)
-}
-
-function splitUpdateAndCommands<T> (updateQuery: UpdateWithAggregationPipeline | UpdateQuery<T> | null): { update: UpdateQuery<T>, commands: Record<string, unknown>[] } {
-  let update: UpdateQuery<T> = {}
-  const commands: Record<string, unknown>[] = []
-
-  if (!_.isEmpty(updateQuery) && !_.isArray(updateQuery) && _.isObjectLike(updateQuery)) {
-    update = _.cloneDeep(updateQuery)
-    const keys = _.keys(update).filter((key) => key.startsWith('$'))
-    if (!_.isEmpty(keys)) {
-      _.forEach(keys, (key) => {
-        commands.push({ [key]: update[key] as unknown })
-        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete update[key]
-      })
-    }
-  }
-
-  return { update, commands }
-}
-
-function assignUpdate<T> (document: HydratedDocument<T>, update: UpdateQuery<T>, commands: Record<string, unknown>[]): HydratedDocument<T> {
-  let updated = assign(document, update)
-  _.forEach(commands, (command) => {
-    try {
-      updated = assign(updated, command)
-    } catch {
-      // we catch assign keys that are not implemented
-    }
-  })
-
-  return updated
-}
-
 /**
  * @description Patch patch event emitter
  */
@@ -86,27 +27,12 @@ export const patchEventEmitter = em
  * @returns {void}
  */
 export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: IPluginOptions<T>): void {
-  schema.pre('save', async function () {
-    const current = this.toObject(toObjectOptions) as HydratedDocument<T>
-    const model = this.constructor as Model<T>
-
-    const context: IContext<T> = {
-      op: this.isNew ? 'create' : 'update',
-      modelName: opts.modelName ?? model.modelName,
-      collectionName: opts.collectionName ?? model.collection.collectionName,
-      createdDocs: [current]
-    }
-
-    if (this.isNew) {
-      await createPatch(opts, context)
-    } else {
-      const original = await model.findById(current._id).lean().exec()
-      if (original) {
-        await updatePatch(opts, context, current, original as HydratedDocument<T>)
-      }
-    }
-  })
-
+  // Initialize hooks
+  saveHooksInitialize(schema, opts)
+  updateHooksInitialize(schema, opts)
+  deleteHooksInitialize(schema, opts)
+  
+  // Corner case for insertMany()
   schema.post('insertMany', async function (docs) {
     const context = {
       op: 'create',
@@ -118,111 +44,33 @@ export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: I
     await createPatch(opts, context)
   })
 
-  schema.pre(updateMethods as MongooseQueryMiddleware[], async function (this: IHookContext<T>) {
-    const options = this.getOptions()
-    if (isHookIgnored(options)) return
-
-    const model = this.model as Model<T>
-    const filter = this.getFilter()
-    const count = await this.model.count(filter).exec()
-
-    this._context = {
-      op: this.op,
-      modelName: opts.modelName ?? this.model.modelName,
-      collectionName: opts.collectionName ?? this.model.collection.collectionName,
-      isNew: options.upsert && count === 0,
-      ignoreEvent: options.ignoreEvent as boolean,
-      ignorePatchHistory: options.ignorePatchHistory as boolean
-    }
-
-    const updateQuery = this.getUpdate()
-    const { update, commands } = splitUpdateAndCommands(updateQuery)
-
-    const cursor = model.find(filter).lean().cursor()
-    await cursor.eachAsync(async (doc: HydratedDocument<T>) => {
-      await updatePatch(opts, this._context, assignUpdate(doc, update, commands), doc)
-    })
-  })
-
-  schema.post(updateMethods as MongooseQueryMiddleware[], async function (this: IHookContext<T>) {
-    const options = this.getOptions()
-    if (isHookIgnored(options)) return
-
-    if (!this._context.isNew) return
-
-    const model = this.model as Model<T>
-    const updateQuery = this.getUpdate()
-    const { update, commands } = splitUpdateAndCommands(updateQuery)
-
-    const filter = assignUpdate({} as HydratedDocument<T>, update, commands)
-    if (!_.isEmpty(filter)) {
-      const current = await model.findOne(update).lean().exec()
-      if (current) {
-        this._context.createdDocs = [current] as HydratedDocument<T>[]
-
-        await createPatch(opts, this._context)
+  // In Mongoose 7, doc.deleteOne() returned a promise that resolved to doc.
+  // In Mongoose 8, doc.deleteOne() returns a query for easier chaining, as well as consistency with doc.updateOne().
+  if (isMongooseLessThan8) {
+    // @ts-expect-error - Mongoose 7 and below
+    schema.pre(remove, { document: true, query: false }, async function () {
+      // @ts-expect-error - Mongoose 7 and below
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      const original = this.toObject(toObjectOptions) as HydratedDocument<T>
+  
+      if (opts.preDelete && !_.isEmpty(original)) {
+        await opts.preDelete([original])
       }
-    }
-  })
-
-  schema.pre(remove, { document: true, query: false }, async function () {
-    const original = this.toObject(toObjectOptions) as HydratedDocument<T>
-
-    if (opts.preDelete && !_.isEmpty(original)) {
-      await opts.preDelete([original])
-    }
-  })
-
-  schema.post(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
-    const original = this.toObject(toObjectOptions) as HydratedDocument<T>
-    const model = this.constructor as Model<T>
-
-    const context: IContext<T> = {
-      op: 'delete',
-      modelName: opts.modelName ?? model.modelName,
-      collectionName: opts.collectionName ?? model.collection.collectionName,
-      deletedDocs: [original]
-    }
-
-    await deletePatch(opts, context)
-  })
-
-  schema.pre(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: IHookContext<T>) {
-    const options = this.getOptions()
-    if (isHookIgnored(options)) return
-
-    const model = this.model as Model<T>
-    const filter = this.getFilter()
-
-    this._context = {
-      op: this.op,
-      modelName: opts.modelName ?? this.model.modelName,
-      collectionName: opts.collectionName ?? this.model.collection.collectionName,
-      ignoreEvent: options.ignoreEvent as boolean,
-      ignorePatchHistory: options.ignorePatchHistory as boolean
-    }
-
-    if (['remove', 'deleteMany'].includes(this._context.op) && !options.single) {
-      const docs = await model.find(filter).lean().exec()
-      if (!_.isEmpty(docs)) {
-        this._context.deletedDocs = docs as HydratedDocument<T>[]
-      }
-    } else {
-      const doc = await model.findOne(filter).lean().exec()
-      if (!_.isEmpty(doc)) {
-        this._context.deletedDocs = [doc] as HydratedDocument<T>[]
+    })
+  
+    // @ts-expect-error - Mongoose 7 and below
+    schema.post(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
+      const original = this.toObject(toObjectOptions) as HydratedDocument<T>
+      const model = this.constructor as Model<T>
+  
+      const context: IContext<T> = {
+        op: 'delete',
+        modelName: opts.modelName ?? model.modelName,
+        collectionName: opts.collectionName ?? model.collection.collectionName,
+        deletedDocs: [original]
       }
-    }
-
-    if (opts.preDelete && _.isArray(this._context.deletedDocs) && !_.isEmpty(this._context.deletedDocs)) {
-      await opts.preDelete(this._context.deletedDocs)
-    }
-  })
-
-  schema.post(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: IHookContext<T>) {
-    const options = this.getOptions()
-    if (isHookIgnored(options)) return
-
-    await deletePatch(opts, this._context)
-  })
+  
+      await deletePatch(opts, context)
+    })
+  }
 }

package/src/version.ts

@@ -1,6 +1,7 @@
 import { satisfies } from 'semver'
 import mongoose from 'mongoose'
 
+export const isMongooseLessThan8 = satisfies(mongoose.version, '<8')
 export const isMongooseLessThan7 = satisfies(mongoose.version, '<7')
 export const isMongoose6 = satisfies(mongoose.version, '6')
 

package/tests/plugin-event-deleted.test.ts

@@ -1,14 +1,13 @@
 import { isMongooseLessThan7 } from '../src/version'
 import mongoose, { model } from 'mongoose'
 
-import type { ToObjectOptions } from 'mongoose'
-
 import UserSchema from './schemas/UserSchema'
 import { patchHistoryPlugin } from '../src/plugin'
 import History from '../src/models/History'
 
 import em from '../src/em'
 import { USER_DELETED } from './constants/events'
+import { toObjectOptions } from '../src/helpers'
 
 jest.mock('../src/em', () => {
   return {
@@ -16,10 +15,6 @@ jest.mock('../src/em', () => {
   }
 })
 
-const toObjectOptions: ToObjectOptions = {
-  depopulate: true,
-  virtuals: false
-}
 
 describe('plugin - event delete & patch history disabled', () => {
   const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
@@ -164,13 +159,17 @@ describe('plugin - event delete & patch history disabled', () => {
   it('should findOneAndRemove() and emit one delete event', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
-      { name: 'Alice', role: 'user' },
+      { name: 'Alice', role: 'admin' },
       { name: 'Bob', role: 'admin' }
     ])
 
     const [john] = users
 
-    await User.findOneAndRemove({ role: 'user' }).exec()
+    if (isMongooseLessThan7) {
+      await User.findOneAndRemove({ role: 'user' }).exec()
+    } else {
+      await User.findOneAndDelete({ role: 'user' }).exec()
+    }
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
@@ -224,7 +223,11 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.findByIdAndRemove(john._id).exec()
+    if (isMongooseLessThan7) {
+      await User.findByIdAndRemove(john._id).exec()
+    } else {
+      await User.findByIdAndDelete(john._id).exec()
+    }
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
@@ -245,7 +248,7 @@ describe('plugin - event delete & patch history disabled', () => {
   it('should deleteOne() and emit one delete event', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
-      { name: 'Alice', role: 'user' },
+      { name: 'Alice', role: 'admin' },
       { name: 'Bob', role: 'admin' }
     ])