ts-patch-mongoose 2.9.5 → 3.0.0

package/src/helpers.ts

@@ -1,8 +1,122 @@
-import ms from 'ms'
 import { HistoryModel } from './model'
+import { type Duration, ms } from './ms'
 
 import type { QueryOptions, ToObjectOptions } from 'mongoose'
 
+export const isArray = Array.isArray
+
+export const isEmpty = (value: unknown): boolean => {
+  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
+}
+
+export const isFunction = (value: unknown): value is (...args: unknown[]) => unknown => {
+  return typeof value === 'function'
+}
+
+export const isObjectLike = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null
+}
+
+const cloneArrayBuffer = (arrayBuffer: ArrayBuffer): ArrayBuffer => {
+  const result = new ArrayBuffer(arrayBuffer.byteLength)
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer))
+  return result
+}
+
+const cloneImmutable = <T>(value: T): T | undefined => {
+  const tag = Object.prototype.toString.call(value)
+
+  switch (tag) {
+    case '[object Date]':
+      return new Date(+(value as unknown as Date)) as T
+    case '[object RegExp]': {
+      const re = value as unknown as RegExp
+      const cloned = new RegExp(re.source, re.flags)
+      cloned.lastIndex = re.lastIndex
+      return cloned as T
+    }
+    case '[object ArrayBuffer]':
+      return cloneArrayBuffer(value as unknown as ArrayBuffer) as T
+    case '[object DataView]': {
+      const dv = value as unknown as DataView
+      const buffer = cloneArrayBuffer(dv.buffer as ArrayBuffer)
+      return new DataView(buffer, dv.byteOffset, dv.byteLength) as T
+    }
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    const ta = value as unknown as { buffer: ArrayBuffer; byteOffset: number; length: number }
+    const buffer = cloneArrayBuffer(ta.buffer)
+    return new (value.constructor as new (buffer: ArrayBuffer, byteOffset: number, length: number) => T)(buffer, ta.byteOffset, ta.length)
+  }
+
+  return undefined
+}
+
+const cloneCollection = <T extends object>(value: T, seen: WeakMap<object, unknown>): T => {
+  if (value instanceof Map) {
+    const map = new Map()
+    seen.set(value, map)
+    for (const [k, v] of value) map.set(k, cloneDeep(v, seen))
+    return map as T
+  }
+
+  if (value instanceof Set) {
+    const set = new Set()
+    seen.set(value, set)
+    for (const v of value) set.add(cloneDeep(v, seen))
+    return set as T
+  }
+
+  if (Array.isArray(value)) {
+    const arr = new Array(value.length) as unknown[]
+    seen.set(value, arr)
+    for (let i = 0; i < value.length; i++) {
+      arr[i] = cloneDeep(value[i], seen)
+    }
+    return arr as T
+  }
+
+  const result = typeof value.constructor === 'function' ? (Object.create(Object.getPrototypeOf(value) as object) as T) : ({} as T)
+  seen.set(value, result)
+  for (const key of Object.keys(value)) {
+    ;(result as Record<string, unknown>)[key] = cloneDeep((value as Record<string, unknown>)[key], seen)
+  }
+  return result
+}
+
+export const cloneDeep = <T>(value: T, seen = new WeakMap<object, unknown>()): T => {
+  if (value === null || typeof value !== 'object') return value
+  if (seen.has(value)) return seen.get(value) as T
+
+  const immutable = cloneImmutable(value)
+  if (immutable !== undefined) return immutable
+
+  if ('toJSON' in value && typeof (value as Record<string, unknown>).toJSON === 'function') {
+    // NOSONAR — structuredClone cannot handle objects with non-cloneable methods (e.g. mongoose documents)
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+
+  return cloneCollection(value, seen)
+}
+
+export const chunk = <T>(array: T[], size: number): T[][] => {
+  const result: T[][] = []
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size))
+  }
+  return result
+}
+
 export const isHookIgnored = <T>(options: QueryOptions<T>): boolean => {
   return options.ignoreHook === true || (options.ignoreEvent === true && options.ignorePatchHistory === true)
 }
@@ -12,21 +126,19 @@ export const toObjectOptions: ToObjectOptions = {
   virtuals: false,
 }
 
-export const setPatchHistoryTTL = async (ttl: number | ms.StringValue): Promise<void> => {
-  const name = 'createdAt_1_TTL' // To avoid collision with user defined index / manually created index
+export const setPatchHistoryTTL = async (ttl: Duration): Promise<void> => {
+  const name = 'createdAt_1_TTL'
   try {
     const indexes = await HistoryModel.collection.indexes()
     const existingIndex = indexes?.find((index) => index.name === name)
 
-    // Drop the index if historyTTL is not set and index exists
     if (!ttl && existingIndex) {
       await HistoryModel.collection.dropIndex(name)
       return
     }
 
-    const milliseconds = typeof ttl === 'string' ? ms(ttl) : ttl
+    const milliseconds = ms(ttl)
 
-    // Drop the index if historyTTL is less than 1 second and index exists
     if (milliseconds < 1000 && existingIndex) {
       await HistoryModel.collection.dropIndex(name)
       return
@@ -35,16 +147,13 @@ export const setPatchHistoryTTL = async (ttl: number | ms.StringValue): Promise<
     const expireAfterSeconds = milliseconds / 1000
 
     if (existingIndex && existingIndex.expireAfterSeconds === expireAfterSeconds) {
-      // Index already exists with the correct TTL, no need to recreate
       return
     }
 
     if (existingIndex) {
-      // Drop the existing index if it exists and TTL is different
       await HistoryModel.collection.dropIndex(name)
     }
 
-    // Create a new index with the correct TTL if it doesn't exist or if the TTL is different
     await HistoryModel.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds, name })
   } catch (err) {
     console.error("Couldn't create or update index for history collection", err)

package/src/hooks/delete-hooks.ts

@@ -1,7 +1,4 @@
-// Using CJS lodash with .js extensions for ESM compatibility
-import isArray from 'lodash/isArray.js'
-import isEmpty from 'lodash/isEmpty.js'
-import { isHookIgnored } from '../helpers'
+import { isArray, isEmpty, isHookIgnored } from '../helpers'
 import { deletePatch } from '../patch'
 
 import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema } from 'mongoose'

package/src/hooks/update-hooks.ts

@@ -1,12 +1,5 @@
-// Using CJS lodash with .js extensions for ESM compatibility
-import cloneDeep from 'lodash/cloneDeep.js'
-import forEach from 'lodash/forEach.js'
-import isArray from 'lodash/isArray.js'
-import isEmpty from 'lodash/isEmpty.js'
-import isObjectLike from 'lodash/isObjectLike.js'
-import keys from 'lodash/keys.js'
 import { assign } from 'power-assign'
-import { isHookIgnored, toObjectOptions } from '../helpers'
+import { cloneDeep, isArray, isEmpty, isHookIgnored, isObjectLike, toObjectOptions } from '../helpers'
 import { createPatch, updatePatch } from '../patch'
 
 import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema, UpdateQuery, UpdateWithAggregationPipeline } from 'mongoose'
@@ -16,14 +9,13 @@ const updateMethods = ['update', 'updateOne', 'replaceOne', 'updateMany', 'findO
 
 export const assignUpdate = <T>(document: HydratedDocument<T>, update: UpdateQuery<T>, commands: Record<string, unknown>[]): HydratedDocument<T> => {
   let updated = assign(document.toObject(toObjectOptions), update)
-  // Try catch not working for of loop, keep it as is
-  forEach(commands, (command) => {
+  for (const command of commands) {
     try {
       updated = assign(updated, command)
     } catch {
       // we catch assign keys that are not implemented
     }
-  })
+  }
 
   const doc = document.set(updated).toObject(toObjectOptions) as HydratedDocument<T> & { createdAt?: Date }
   if (update.createdAt) doc.createdAt = update.createdAt
@@ -36,12 +28,12 @@ export const splitUpdateAndCommands = <T>(updateQuery: UpdateWithAggregationPipe
 
   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] as unknown })
         delete update[key]
-      })
+      }
     }
   }
 
@@ -98,7 +90,6 @@ export const updateHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<
     }
 
     if (!isEmpty(filter) && !current) {
-      console.log('filter', filter)
       current = (await model.findOne(filter).sort('desc').lean().exec()) as HydratedDocument<T>
     }
 

package/src/index.ts

@@ -1,6 +1,4 @@
-// Using CJS lodash with .js extension for ESM compatibility
-import isEmpty from 'lodash/isEmpty.js'
-import { toObjectOptions } from './helpers'
+import { isEmpty, toObjectOptions } from './helpers'
 import { deleteHooksInitialize } from './hooks/delete-hooks'
 import { saveHooksInitialize } from './hooks/save-hooks'
 import { updateHooksInitialize } from './hooks/update-hooks'
@@ -12,34 +10,17 @@ import type { PatchContext, PluginOptions } from './types'
 
 const remove = isMongooseLessThan7 ? 'remove' : 'deleteOne'
 
-/**
- * @description Event emitter for patch operations.
- */
 export { default as patchEventEmitter } from './em'
 export { setPatchHistoryTTL } from './helpers'
 export * from './types'
 
-/**
- * @description Mongoose plugin to track and manage patch history for documents.
- * This plugin initializes hooks for save, update, and delete operations to create
- * and manage patches.
- *
- * @template T
- * @param {Schema<T>} schema - The Mongoose schema to apply the plugin to.
- * @param {PluginOptions<T>} opts - Options for configuring the plugin.
- * @returns {void}
- */
-export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: PluginOptions<T>): void {
-  // Initialize hooks
+export type { Duration } from './ms'
+
+export const patchHistoryPlugin = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
   saveHooksInitialize(schema, opts)
   updateHooksInitialize(schema, opts)
   deleteHooksInitialize(schema, opts)
 
-  /**
-   * @description Corner case for insertMany()
-   * @param {Array<HydratedDocument<T>>} docs - The documents being inserted.
-   * @returns {Promise<void>}
-   */
   schema.post('insertMany', async function (docs) {
     const context = {
       op: 'create',
@@ -55,10 +36,6 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: Pl
   // 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) {
-    /**
-     * @description Pre-delete hook for Mongoose 7 and below
-     * @returns {Promise<void>}
-     */
     // @ts-expect-error - Mongoose 7 and below
     schema.pre(remove, { document: true, query: false }, async function () {
       // @ts-expect-error - Mongoose 7 and below
@@ -69,11 +46,6 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: Pl
       }
     })
 
-    /**
-     * @description Post-delete hook for Mongoose 7 and below
-     * @param {HydratedDocument<T>} this - The document being deleted.
-     * @returns {Promise<void>}
-     */
     // @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>

package/src/ms.ts

@@ -0,0 +1,66 @@
+const s = 1000
+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
+
+export 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,
+} as const satisfies Record<string, number>
+
+export type Unit = keyof typeof UNITS
+
+export type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`
+
+const unitPattern = Object.keys(UNITS)
+  .sort((a, b) => b.length - a.length)
+  .join('|')
+
+const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, 'i')
+
+export const ms = (val: Duration): number => {
+  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 as Unit] ?? 0)
+}

package/src/omit-deep.ts

@@ -0,0 +1,95 @@
+const isPlainObject = (val: unknown): val is Record<string, unknown> => {
+  if (Object.prototype.toString.call(val) !== '[object Object]') return false
+  const prot = Object.getPrototypeOf(val) as object | null
+  return prot === null || prot === Object.prototype
+}
+
+const isUnsafeKey = (key: string): boolean => {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype'
+}
+
+const getValue = (obj: Record<string, unknown>, path: string): unknown => {
+  const segs = path.split('.')
+  let current: unknown = obj
+  for (const seg of segs) {
+    if (current == null || typeof current !== 'object') return undefined
+    current = (current as Record<string, unknown>)[seg]
+  }
+  return current
+}
+
+const hasValue = (val: unknown): boolean => {
+  if (val == null) return false
+  if (typeof val === 'boolean' || typeof val === 'number' || typeof val === 'function') return true
+  if (typeof val === 'string') return val.length !== 0
+  if (Array.isArray(val)) return val.length !== 0
+  if (val instanceof RegExp) return val.source !== '(?:)' && val.source !== ''
+  if (val instanceof Error) return val.message !== ''
+  if (val instanceof Map || val instanceof Set) return val.size !== 0
+  if (typeof val === 'object') {
+    for (const key of Object.keys(val)) {
+      if (hasValue((val as Record<string, unknown>)[key])) return true
+    }
+    return false
+  }
+  return true
+}
+
+const has = (obj: unknown, path: string): boolean => {
+  if (obj != null && typeof obj === 'object' && typeof path === 'string') {
+    return hasValue(getValue(obj as Record<string, unknown>, path))
+  }
+  return false
+}
+
+const unset = (obj: Record<string, unknown>, prop: string): boolean => {
+  if (typeof obj !== 'object' || obj === null) return false
+
+  if (Object.hasOwn(obj, prop)) {
+    delete obj[prop]
+    return true
+  }
+
+  if (has(obj, prop)) {
+    const segs = prop.split('.')
+    let last = segs.pop()
+    while (segs.length && segs.at(-1)?.slice(-1) === '\\') {
+      last = `${(segs.pop() as string).slice(0, -1)}.${last}`
+    }
+    let target: unknown = obj
+    while (segs.length) {
+      const seg = segs.shift() as string
+      if (isUnsafeKey(seg)) return false
+      target = (target as Record<string, unknown>)[seg]
+    }
+    return delete (target as Record<string, unknown>)[last ?? '']
+  }
+
+  return true
+}
+
+export const omitDeep = <T>(value: T, keys: string | string[]): T => {
+  if (value === undefined) return {} as T
+
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = omitDeep(value[i], keys)
+    }
+    return value
+  }
+
+  if (!isPlainObject(value)) return value
+
+  const omitKeys = typeof keys === 'string' ? [keys] : keys
+  if (!Array.isArray(omitKeys)) return value
+
+  for (const key of omitKeys) {
+    unset(value, key)
+  }
+
+  for (const key of Object.keys(value)) {
+    ;(value as Record<string, unknown>)[key] = omitDeep((value as Record<string, unknown>)[key], omitKeys)
+  }
+
+  return value
+}

package/src/patch.ts

@@ -1,20 +1,18 @@
 import jsonpatch from 'fast-json-patch'
-// Using CJS lodash with .js extensions for ESM compatibility
-import chunk from 'lodash/chunk.js'
-import isEmpty from 'lodash/isEmpty.js'
-import isFunction from 'lodash/isFunction.js'
-import omit from 'omit-deep'
 import em from './em'
+import { chunk, isEmpty, isFunction } from './helpers'
 import { HistoryModel } from './model'
+import { omitDeep as omit } from './omit-deep'
 
 import type { HydratedDocument, MongooseError, Types } from 'mongoose'
 import type { Metadata, PatchContext, PatchEvent, PluginOptions, User } from './types'
 
-function isPatchHistoryEnabled<T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean {
+const isPatchHistoryEnabled = <T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean => {
   return !opts.patchHistoryDisabled && !context.ignorePatchHistory
 }
 
-export function getJsonOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> {
+export const getJsonOmit = <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> => {
+  // NOSONAR — structuredClone cannot handle mongoose documents (they contain non-cloneable methods)
   const object = JSON.parse(JSON.stringify(doc)) as Partial<T>
 
   if (opts.omit) {
@@ -24,7 +22,7 @@ export function getJsonOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>)
   return object
 }
 
-export function getObjectOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> {
+export const getObjectOmit = <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> => {
   if (opts.omit) {
     return omit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit)
   }
@@ -32,56 +30,56 @@ export function getObjectOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T
   return doc
 }
 
-export async function getUser<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<User | undefined> {
+export const getUser = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<User | undefined> => {
   if (isFunction(opts.getUser)) {
     return await opts.getUser(doc)
   }
   return undefined
 }
 
-export async function getReason<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<string | undefined> {
+export const getReason = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<string | undefined> => {
   if (isFunction(opts.getReason)) {
     return await opts.getReason(doc)
   }
   return undefined
 }
 
-export async function getMetadata<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<Metadata | undefined> {
+export const getMetadata = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<Metadata | undefined> => {
   if (isFunction(opts.getMetadata)) {
     return await opts.getMetadata(doc)
   }
   return undefined
 }
 
-export function getValue<T>(item: PromiseSettledResult<T>): T | undefined {
+export const getValue = <T>(item: PromiseSettledResult<T>): T | undefined => {
   return item.status === 'fulfilled' ? item.value : undefined
 }
 
-export async function getData<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<[User | undefined, string | undefined, Metadata | undefined]> {
+export const getData = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<[User | undefined, string | undefined, Metadata | undefined]> => {
   return Promise.allSettled([getUser(opts, doc), getReason(opts, doc), getMetadata(opts, doc)]).then(([user, reason, metadata]) => {
     return [getValue(user), getValue(reason), getValue(metadata)]
   })
 }
 
-export function emitEvent<T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void {
+export const emitEvent = <T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void => {
   if (event && !context.ignoreEvent) {
     em.emit(event, data)
   }
 }
 
-export async function bulkPatch<T>(opts: PluginOptions<T>, context: PatchContext<T>, eventKey: 'eventCreated' | 'eventDeleted', docsKey: 'createdDocs' | 'deletedDocs'): Promise<void> {
+export const bulkPatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>, eventKey: 'eventCreated' | 'eventDeleted', docsKey: 'createdDocs' | 'deletedDocs'): Promise<void> => {
   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, 1000)
-  for (const chunk of chunks) {
+  for (const batch of chunks) {
     const bulk = []
 
-    for (const doc of chunk) {
+    for (const doc of batch) {
       emitEvent(context, event, { [key]: doc })
 
       if (history) {
@@ -94,10 +92,10 @@ export async function bulkPatch<T>(opts: PluginOptions<T>, context: PatchContext
               collectionName: context.collectionName,
               collectionId: doc._id as Types.ObjectId,
               doc: getObjectOmit(opts, doc),
-              user,
-              reason,
-              metadata,
               version: 0,
+              ...(user !== undefined && { user }),
+              ...(reason !== undefined && { reason }),
+              ...(metadata !== undefined && { metadata }),
             },
           },
         })
@@ -112,11 +110,11 @@ export async function bulkPatch<T>(opts: PluginOptions<T>, context: PatchContext
   }
 }
 
-export async function createPatch<T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> {
+export const createPatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
   await bulkPatch(opts, context, 'eventCreated', 'createdDocs')
 }
 
-export async function updatePatch<T>(opts: PluginOptions<T>, context: PatchContext<T>, current: HydratedDocument<T>, original: HydratedDocument<T>): Promise<void> {
+export const updatePatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>, current: HydratedDocument<T>, original: HydratedDocument<T>): Promise<void> => {
   const history = isPatchHistoryEnabled(opts, context)
 
   const currentObject = getJsonOmit(opts, current)
@@ -146,14 +144,14 @@ export async function updatePatch<T>(opts: PluginOptions<T>, context: PatchConte
       collectionName: context.collectionName,
       collectionId: original._id as Types.ObjectId,
       patch,
-      user,
-      reason,
-      metadata,
       version,
+      ...(user !== undefined && { user }),
+      ...(reason !== undefined && { reason }),
+      ...(metadata !== undefined && { metadata }),
     })
   }
 }
 
-export async function deletePatch<T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> {
+export const deletePatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
   await bulkPatch(opts, context, 'eventDeleted', 'deletedDocs')
 }

package/src/version.ts

@@ -1,9 +1,10 @@
 import mongoose from 'mongoose'
-import { satisfies } from 'semver'
 
-export const isMongooseLessThan8 = satisfies(mongoose.version, '<8')
-export const isMongooseLessThan7 = satisfies(mongoose.version, '<7')
-export const isMongoose6 = satisfies(mongoose.version, '6')
+const major = Number.parseInt(mongoose.version, 10)
+
+export const isMongooseLessThan8 = major < 8
+export const isMongooseLessThan7 = major < 7
+export const isMongoose6 = major === 6
 
 /* v8 ignore start */
 if (isMongoose6) {

package/tests/em.test.ts

@@ -27,6 +27,7 @@ describe('em', () => {
       collectionName: 'tests',
     }
 
+    // @ts-expect-error expected
     emitEvent(context, 'test', { doc: { name: 'test' } })
     expect(fn).toHaveBeenCalledTimes(1)
 
@@ -44,6 +45,7 @@ describe('em', () => {
       collectionName: 'tests',
     }
 
+    // @ts-expect-error expected
     emitEvent(context, 'test', { doc: { name: 'test' } })
     expect(fn).toHaveBeenCalledTimes(0)