ts-patch-mongoose 2.9.6 → 3.1.0

package/README.md

@@ -23,8 +23,8 @@ I need to track changes of mongoose models and save them as patch history (audit
 
 ```json
 {
-  "node": "18.x || 20.x || 22.x",
-  "mongoose": ">=6.6.x || 7.x || 8.x",
+  "node": "20.x || 22.x || 24.x",
+  "mongoose": ">=6.6.x || 7.x || 8.x || 9.x",
 }
 ```
 
@@ -40,37 +40,19 @@ I need to track changes of mongoose models and save them as patch history (audit
 
 ## Installation
 
-- Locally inside your project
+`mongoose` is a peer dependency — install it alongside `ts-patch-mongoose`.
 
 ```bash
-npm install ts-patch-mongoose
-pnpm add ts-patch-mongoose
-yarn add ts-patch-mongoose
-bun add ts-patch-mongoose
-```
-
-- This plugin requires mongoose `>=6.6.x || 7.x || 8.x` to be installed as a peer dependency
-
-```bash
-# For latest mongoose 6
-npm install mongoose@6
-pnpm add mongoose@6
-yarn add mongoose@6
-bun add mongoose@6
-# For latest mongoose 7
-npm install mongoose@7
-pnpm add mongoose@7
-yarn add mongoose@7
-bun add mongoose@7
-# For latest mongoose 8
-npm install mongoose@8
-pnpm add mongoose@8
-yarn add mongoose@8
-bun add mongoose@8
+npm install ts-patch-mongoose mongoose
+pnpm add ts-patch-mongoose mongoose
+yarn add ts-patch-mongoose mongoose
+bun add ts-patch-mongoose mongoose
 ```
 
 ## Example
 
+Works with any Node.js framework — Express, Fastify, Koa, Hono, Nest, etc.
+\
 How to use it with express [ts-express-tsx](https://github.com/ilovepixelart/ts-express-tsx)
 
 Create your event constants `events.ts`
@@ -213,6 +195,39 @@ patchEventEmitter.on(BOOK_DELETED, ({ oldDoc }) => {
 })
 ```
 
+## NestJS
+
+```typescript
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { patchHistoryPlugin } from 'ts-patch-mongoose'
+
+@Schema({ timestamps: true })
+export class Book {
+  @Prop({ type: String, required: true })
+  title!: string
+
+  @Prop({ type: String })
+  description?: string
+}
+
+export const BookSchema = SchemaFactory.createForClass(Book)
+
+BookSchema.plugin(patchHistoryPlugin, {
+  eventCreated: 'book-created',
+  eventUpdated: 'book-updated',
+  eventDeleted: 'book-deleted',
+  omit: ['__v', 'createdAt', 'updatedAt'],
+})
+```
+
+## Contributing
+
+Check [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
+
 ## Check my other projects
 
 - [ts-migrate-mongoose](https://github.com/ilovepixelart/ts-migrate-mongoose) - Migration framework for mongoose

package/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.4.4/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.4.9/schema.json",
   "vcs": { "enabled": false, "clientKind": "git", "useIgnoreFile": false },
   "files": {
     "ignoreUnknown": false,
@@ -27,10 +27,7 @@
   "linter": {
     "enabled": true,
     "rules": {
-      "recommended": true,
-      "correctness": {
-        "noUnusedVariables": "off"
-      }
+      "recommended": true
     }
   },
   "javascript": {

package/dist/index.cjs

@@ -1,20 +1,9 @@
 'use strict';
 
-var isEmpty = require('lodash/isEmpty.js');
-var ms = require('ms');
 var mongoose = require('mongoose');
-var isArray = require('lodash/isArray.js');
 var jsonpatch = require('fast-json-patch');
-var chunk = require('lodash/chunk.js');
-var isFunction = require('lodash/isFunction.js');
-var omit = require('omit-deep');
 var EventEmitter = require('node:events');
-var cloneDeep = require('lodash/cloneDeep.js');
-var forEach = require('lodash/forEach.js');
-var isObjectLike = require('lodash/isObjectLike.js');
-var keys = require('lodash/keys.js');
 var powerAssign = require('power-assign');
-var semver = require('semver');
 
 const HistorySchema = new mongoose.Schema(
   {
@@ -61,6 +50,166 @@ HistorySchema.index({ collectionId: 1, version: -1 });
 HistorySchema.index({ op: 1, modelName: 1, collectionName: 1, collectionId: 1, reason: 1, version: 1 });
 const HistoryModel = mongoose.model("History", HistorySchema, "history");
 
+const s = 1e3;
+const m = s * 60;
+const h = m * 60;
+const d = h * 24;
+const w = d * 7;
+const y = d * 365.25;
+const mo = y / 12;
+const UNITS = {
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  minutes: m,
+  minute: m,
+  mins: m,
+  min: m,
+  m,
+  hours: h,
+  hour: h,
+  hrs: h,
+  hr: h,
+  h,
+  days: d,
+  day: d,
+  d,
+  weeks: w,
+  week: w,
+  w,
+  months: mo,
+  month: mo,
+  mo,
+  years: y,
+  year: y,
+  yrs: y,
+  yr: y,
+  y
+};
+const unitPattern = Object.keys(UNITS).sort((a, b) => b.length - a.length).join("|");
+const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, "i");
+const ms = (val) => {
+  const str = String(val);
+  if (str.length > 100) return Number.NaN;
+  const match = RE.exec(str);
+  if (!match) return Number.NaN;
+  const n = Number.parseFloat(match[1] ?? "");
+  const type = (match[2] ?? "ms").toLowerCase();
+  return n * (UNITS[type] ?? 0);
+};
+
+const isArray = Array.isArray;
+const isEmpty = (value) => {
+  if (value == null) return true;
+  if (Array.isArray(value) || typeof value === "string") return value.length === 0;
+  if (value instanceof Map || value instanceof Set) return value.size === 0;
+  if (typeof value === "object") {
+    for (const key in value) {
+      if (Object.hasOwn(value, key)) return false;
+    }
+    return true;
+  }
+  return true;
+};
+const isFunction = (value) => {
+  return typeof value === "function";
+};
+const isObjectLike = (value) => {
+  return typeof value === "object" && value !== null;
+};
+const cloneArrayBuffer = (arrayBuffer) => {
+  const result = new ArrayBuffer(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+};
+const cloneImmutable = (value) => {
+  const tag = Object.prototype.toString.call(value);
+  switch (tag) {
+    case "[object Date]":
+      return /* @__PURE__ */ new Date(+value);
+    case "[object RegExp]": {
+      const re = value;
+      const cloned = new RegExp(re.source, re.flags);
+      cloned.lastIndex = re.lastIndex;
+      return cloned;
+    }
+    case "[object Error]": {
+      const err = value;
+      const cloned = new err.constructor(err.message);
+      if (err.stack) cloned.stack = err.stack;
+      return cloned;
+    }
+    case "[object ArrayBuffer]":
+      return cloneArrayBuffer(value);
+    case "[object DataView]": {
+      const dv = value;
+      const buffer = cloneArrayBuffer(dv.buffer);
+      return new DataView(buffer, dv.byteOffset, dv.byteLength);
+    }
+  }
+  if (ArrayBuffer.isView(value)) {
+    const ta = value;
+    const buffer = cloneArrayBuffer(ta.buffer);
+    return new value.constructor(buffer, ta.byteOffset, ta.length);
+  }
+  return void 0;
+};
+const cloneCollection = (value, seen) => {
+  if (value instanceof Map) {
+    const map = /* @__PURE__ */ new Map();
+    seen.set(value, map);
+    for (const [k, v] of value) map.set(k, cloneDeep(v, seen));
+    return map;
+  }
+  if (value instanceof Set) {
+    const set = /* @__PURE__ */ new Set();
+    seen.set(value, set);
+    for (const v of value) set.add(cloneDeep(v, seen));
+    return set;
+  }
+  if (Array.isArray(value)) {
+    const arr = new Array(value.length);
+    seen.set(value, arr);
+    for (let i = 0; i < value.length; i++) {
+      arr[i] = cloneDeep(value[i], seen);
+    }
+    return arr;
+  }
+  const result = typeof value.constructor === "function" ? Object.create(Object.getPrototypeOf(value)) : {};
+  seen.set(value, result);
+  for (const key of Object.keys(value)) {
+    result[key] = cloneDeep(value[key], seen);
+  }
+  return result;
+};
+const cloneDeep = (value, seen = /* @__PURE__ */ new WeakMap()) => {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  const immutable = cloneImmutable(value);
+  if (immutable !== void 0) return immutable;
+  const record = value;
+  if (typeof record._bsontype === "string" && typeof record.toHexString === "function") {
+    return new value.constructor(record.toHexString());
+  }
+  if (typeof record.toJSON === "function") {
+    return JSON.parse(JSON.stringify(value));
+  }
+  return cloneCollection(value, seen);
+};
+const chunk = (array, size) => {
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+};
 const isHookIgnored = (options) => {
   return options.ignoreHook === true || options.ignoreEvent === true && options.ignorePatchHistory === true;
 };
@@ -68,7 +217,7 @@ const toObjectOptions = {
   depopulate: true,
   virtuals: false
 };
-const setPatchHistoryTTL = async (ttl) => {
+const setPatchHistoryTTL = async (ttl, onError) => {
   const name = "createdAt_1_TTL";
   try {
     const indexes = await HistoryModel.collection.indexes();
@@ -77,7 +226,7 @@ const setPatchHistoryTTL = async (ttl) => {
       await HistoryModel.collection.dropIndex(name);
       return;
     }
-    const milliseconds = typeof ttl === "string" ? ms(ttl) : ttl;
+    const milliseconds = ms(ttl);
     if (milliseconds < 1e3 && existingIndex) {
       await HistoryModel.collection.dropIndex(name);
       return;
@@ -91,7 +240,8 @@ const setPatchHistoryTTL = async (ttl) => {
     }
     await HistoryModel.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds, name });
   } catch (err) {
-    console.error("Couldn't create or update index for history collection", err);
+    const handler = onError ?? console.error;
+    handler(err);
   }
 };
 
@@ -99,64 +249,101 @@ class PatchEventEmitter extends EventEmitter {
 }
 const em = new PatchEventEmitter();
 
-function isPatchHistoryEnabled(opts, context) {
-  return !opts.patchHistoryDisabled && !context.ignorePatchHistory;
-}
-function getJsonOmit(opts, doc) {
-  const object = JSON.parse(JSON.stringify(doc));
-  if (opts.omit) {
-    return omit(object, opts.omit);
-  }
-  return object;
-}
-function getObjectOmit(opts, doc) {
-  if (opts.omit) {
-    return omit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit);
+const isPlainObject = (val) => {
+  if (Object.prototype.toString.call(val) !== "[object Object]") return false;
+  const prot = Object.getPrototypeOf(val);
+  return prot === null || prot === Object.prototype;
+};
+const isUnsafeKey = (key) => {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+};
+const classifyKeys = (omitKeys) => {
+  const topLevel = /* @__PURE__ */ new Set();
+  const nested = /* @__PURE__ */ new Map();
+  for (const key of omitKeys) {
+    const dotIdx = key.indexOf(".");
+    if (dotIdx === -1) {
+      topLevel.add(key);
+    } else {
+      const head = key.slice(0, dotIdx);
+      const tail = key.slice(dotIdx + 1);
+      if (!isUnsafeKey(head)) {
+        const existing = nested.get(head) ?? [];
+        existing.push(tail);
+        nested.set(head, existing);
+      }
+    }
   }
-  return doc;
-}
-async function getUser(opts, doc) {
-  if (isFunction(opts.getUser)) {
-    return await opts.getUser(doc);
+  return { topLevel, nested };
+};
+const omitDeep = (value, keys) => {
+  if (value === void 0) return {};
+  if (Array.isArray(value)) {
+    return value.map((item) => omitDeep(item, keys));
   }
-  return void 0;
-}
-async function getReason(opts, doc) {
-  if (isFunction(opts.getReason)) {
-    return await opts.getReason(doc);
+  if (!isPlainObject(value)) return value;
+  const omitKeys = typeof keys === "string" ? [keys] : keys;
+  if (!Array.isArray(omitKeys)) return value;
+  const { topLevel, nested } = classifyKeys(omitKeys);
+  const result = {};
+  for (const key of Object.keys(value)) {
+    if (topLevel.has(key)) continue;
+    const nestedKeys = nested.get(key);
+    result[key] = omitDeep(value[key], nestedKeys ?? omitKeys);
   }
-  return void 0;
-}
-async function getMetadata(opts, doc) {
-  if (isFunction(opts.getMetadata)) {
-    return await opts.getMetadata(doc);
+  return result;
+};
+
+const isPatchHistoryEnabled = (opts, context) => {
+  return !opts.patchHistoryDisabled && !context.ignorePatchHistory;
+};
+const applyOmit = (object, opts) => {
+  return opts.omit ? omitDeep(object, opts.omit) : object;
+};
+const replacer = (_key, value) => typeof value === "bigint" ? value.toString() : value;
+const getJsonOmit = (opts, doc) => {
+  return applyOmit(JSON.parse(JSON.stringify(doc, replacer)), opts);
+};
+const getObjectOmit = (opts, doc) => {
+  return applyOmit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts);
+};
+const getOptionalField = async (fn, doc) => {
+  if (isFunction(fn)) {
+    return await fn(doc);
   }
   return void 0;
-}
-function getValue(item) {
+};
+const getUser = async (opts, doc) => getOptionalField(opts.getUser, doc);
+const getReason = async (opts, doc) => getOptionalField(opts.getReason, doc);
+const getMetadata = async (opts, doc) => getOptionalField(opts.getMetadata, doc);
+const getValue = (item) => {
   return item.status === "fulfilled" ? item.value : void 0;
-}
-async function getData(opts, doc) {
+};
+const getData = async (opts, doc) => {
   return Promise.allSettled([getUser(opts, doc), getReason(opts, doc), getMetadata(opts, doc)]).then(([user, reason, metadata]) => {
     return [getValue(user), getValue(reason), getValue(metadata)];
   });
-}
-function emitEvent(context, event, data) {
+};
+const emitEvent = (context, event, data) => {
   if (event && !context.ignoreEvent) {
-    em.emit(event, data);
+    try {
+      em.emit(event, data);
+    } catch {
+    }
   }
-}
-async function bulkPatch(opts, context, eventKey, docsKey) {
+};
+const bulkPatch = async (opts, context, eventKey, docsKey) => {
   const history = isPatchHistoryEnabled(opts, context);
   const event = opts[eventKey];
   const docs = context[docsKey];
   const key = eventKey === "eventCreated" ? "doc" : "oldDoc";
-  if (isEmpty(docs) || !event && !history) return;
+  if (isEmpty(docs) || !docs || !event && !history) return;
   const chunks = chunk(docs, 1e3);
-  for (const chunk2 of chunks) {
+  for (const batch of chunks) {
     const bulk = [];
-    for (const doc of chunk2) {
-      emitEvent(context, event, { [key]: doc });
+    for (const doc of batch) {
+      const omitted = getObjectOmit(opts, doc);
+      emitEvent(context, event, { [key]: omitted });
       if (history) {
         const [user, reason, metadata] = await getData(opts, doc);
         bulk.push({
@@ -166,7 +353,7 @@ async function bulkPatch(opts, context, eventKey, docsKey) {
               modelName: context.modelName,
               collectionName: context.collectionName,
               collectionId: doc._id,
-              doc: getObjectOmit(opts, doc),
+              doc: omitted,
               version: 0,
               ...user !== void 0 && { user },
               ...reason !== void 0 && { reason },
@@ -177,16 +364,17 @@ async function bulkPatch(opts, context, eventKey, docsKey) {
       }
     }
     if (history && !isEmpty(bulk)) {
+      const onError = opts.onError ?? console.error;
       await HistoryModel.bulkWrite(bulk, { ordered: false }).catch((error) => {
-        console.error(error.message);
+        onError(error);
       });
     }
   }
-}
-async function createPatch(opts, context) {
+};
+const createPatch = async (opts, context) => {
   await bulkPatch(opts, context, "eventCreated", "createdDocs");
-}
-async function updatePatch(opts, context, current, original) {
+};
+const updatePatch = async (opts, context, current, original) => {
   const history = isPatchHistoryEnabled(opts, context);
   const currentObject = getJsonOmit(opts, current);
   const originalObject = getJsonOmit(opts, original);
@@ -201,6 +389,7 @@ async function updatePatch(opts, context, current, original) {
       version = lastHistory.version + 1;
     }
     const [user, reason, metadata] = await getData(opts, current);
+    const onError = opts.onError ?? console.error;
     await HistoryModel.create({
       op: context.op,
       modelName: context.modelName,
@@ -211,12 +400,14 @@ async function updatePatch(opts, context, current, original) {
       ...user !== void 0 && { user },
       ...reason !== void 0 && { reason },
       ...metadata !== void 0 && { metadata }
+    }).catch((error) => {
+      onError(error);
     });
   }
-}
-async function deletePatch(opts, context) {
+};
+const deletePatch = async (opts, context) => {
   await bulkPatch(opts, context, "eventDeleted", "deletedDocs");
-}
+};
 
 const deleteMethods = ["remove", "findOneAndDelete", "findOneAndRemove", "findByIdAndDelete", "findByIdAndRemove", "deleteOne", "deleteMany"];
 const deleteHooksInitialize = (schema, opts) => {
@@ -227,8 +418,8 @@ const deleteHooksInitialize = (schema, opts) => {
     const filter = this.getFilter();
     this._context = {
       op: this.op,
-      modelName: opts.modelName ?? this.model.modelName,
-      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
       ignoreEvent: options.ignoreEvent,
       ignorePatchHistory: options.ignorePatchHistory
     };
@@ -244,12 +435,13 @@ const deleteHooksInitialize = (schema, opts) => {
       }
     }
     if (opts.preDelete && isArray(this._context.deletedDocs) && !isEmpty(this._context.deletedDocs)) {
-      await opts.preDelete(this._context.deletedDocs);
+      await opts.preDelete(cloneDeep(this._context.deletedDocs));
     }
   });
   schema.post(deleteMethods, { document: false, query: true }, async function() {
     const options = this.getOptions();
     if (isHookIgnored(options)) return;
+    if (!this._context) return;
     await deletePatch(opts, this._context);
   });
 };
@@ -277,15 +469,42 @@ const saveHooksInitialize = (schema, opts) => {
 };
 
 const updateMethods = ["update", "updateOne", "replaceOne", "updateMany", "findOneAndUpdate", "findOneAndReplace", "findByIdAndUpdate"];
+const trackChangedFields = (fields, updated, changed) => {
+  if (!fields) return;
+  for (const key of Object.keys(fields)) {
+    const root = key.split(".")[0];
+    changed.set(root, updated[root]);
+  }
+};
+const applyPullAll = (updated, fields, changed) => {
+  for (const [field, values] of Object.entries(fields)) {
+    const arr = updated[field];
+    if (Array.isArray(arr)) {
+      const filtered = arr.filter((item) => !values.some((v) => JSON.stringify(v) === JSON.stringify(item)));
+      updated[field] = filtered;
+      changed.set(field, filtered);
+    }
+  }
+};
 const assignUpdate = (document, update, commands) => {
   let updated = powerAssign.assign(document.toObject(toObjectOptions), update);
-  forEach(commands, (command) => {
+  const changedByCommand = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const op = Object.keys(command)[0];
+    const fields = command[op];
     try {
       updated = powerAssign.assign(updated, command);
+      trackChangedFields(fields, updated, changedByCommand);
     } catch {
+      if (op === "$pullAll" && fields) {
+        applyPullAll(updated, fields, changedByCommand);
+      }
     }
-  });
+  }
   const doc = document.set(updated).toObject(toObjectOptions);
+  for (const [field, value] of changedByCommand) {
+    doc[field] = value;
+  }
   if (update.createdAt) doc.createdAt = update.createdAt;
   return doc;
 };
@@ -294,28 +513,27 @@ const splitUpdateAndCommands = (updateQuery) => {
   const commands = [];
   if (!isEmpty(updateQuery) && !isArray(updateQuery) && isObjectLike(updateQuery)) {
     update = cloneDeep(updateQuery);
-    const keysWithDollarSign = keys(update).filter((key) => key.startsWith("$"));
+    const keysWithDollarSign = Object.keys(update).filter((key) => key.startsWith("$"));
     if (!isEmpty(keysWithDollarSign)) {
-      forEach(keysWithDollarSign, (key) => {
+      for (const key of keysWithDollarSign) {
         commands.push({ [key]: update[key] });
         delete update[key];
-      });
+      }
     }
   }
   return { update, commands };
 };
 const updateHooksInitialize = (schema, opts) => {
-  schema.pre(updateMethods, async function() {
+  schema.pre(updateMethods, { document: false, query: true }, async function() {
     const options = this.getOptions();
     if (isHookIgnored(options)) return;
     const model = this.model;
     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: Boolean(options.upsert) && count === 0,
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
+      isNew: Boolean(options.upsert) && await model.countDocuments(filter).exec() === 0,
       ignoreEvent: options.ignoreEvent,
       ignorePatchHistory: options.ignorePatchHistory
     };
@@ -327,25 +545,20 @@ const updateHooksInitialize = (schema, opts) => {
       await updatePatch(opts, this._context, assignUpdate(doc, update, commands), origDoc);
     });
   });
-  schema.post(updateMethods, async function() {
+  schema.post(updateMethods, { document: false, query: true }, async function() {
     const options = this.getOptions();
     if (isHookIgnored(options)) return;
+    if (!this._context) return;
     if (!this._context.isNew) return;
     const model = this.model;
     const updateQuery = this.getUpdate();
     const { update, commands } = splitUpdateAndCommands(updateQuery);
-    let current = null;
     const filter = this.getFilter();
-    const combined = assignUpdate(model.hydrate({}), update, commands);
-    if (!isEmpty(update) && !current) {
-      current = await model.findOne(update).sort("desc").lean().exec();
-    }
-    if (!isEmpty(combined) && !current) {
-      current = await model.findOne(combined).sort("desc").lean().exec();
-    }
-    if (!isEmpty(filter) && !current) {
-      console.log("filter", filter);
-      current = await model.findOne(filter).sort("desc").lean().exec();
+    const candidates = [update, assignUpdate(model.hydrate({}), update, commands), filter];
+    let current = null;
+    for (const query of candidates) {
+      if (current || isEmpty(query)) continue;
+      current = await model.findOne(query).sort({ _id: -1 }).lean().exec();
     }
     if (current) {
       this._context.createdDocs = [current];
@@ -354,15 +567,16 @@ const updateHooksInitialize = (schema, opts) => {
   });
 };
 
-const isMongooseLessThan8 = semver.satisfies(mongoose.version, "<8");
-const isMongooseLessThan7 = semver.satisfies(mongoose.version, "<7");
-const isMongoose6 = semver.satisfies(mongoose.version, "6");
+const major = Number.parseInt(mongoose.version, 10);
+const isMongooseLessThan8 = major < 8;
+const isMongooseLessThan7 = major < 7;
+const isMongoose6 = major === 6;
 if (isMongoose6) {
   mongoose.set("strictQuery", false);
 }
 
 const remove = isMongooseLessThan7 ? "remove" : "deleteOne";
-const patchHistoryPlugin = function plugin(schema, opts) {
+const patchHistoryPlugin = (schema, opts) => {
   saveHooksInitialize(schema, opts);
   updateHooksInitialize(schema, opts);
   deleteHooksInitialize(schema, opts);