ts-patch-mongoose 3.0.0 → 3.1.0

package/src/omit-deep.ts

@@ -8,74 +8,33 @@ 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 classifyKeys = (omitKeys: string[]): { topLevel: Set<string>; nested: Map<string, string[]> } => {
+  const topLevel = new Set<string>()
+  const nested = new Map<string, string[]>()
 
-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]
+  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 delete (target as Record<string, unknown>)[last ?? '']
   }
 
-  return true
+  return { topLevel, nested }
 }
 
 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
+    return value.map((item) => omitDeep(item, keys)) as T
   }
 
   if (!isPlainObject(value)) return value
@@ -83,13 +42,15 @@ export const omitDeep = <T>(value: T, keys: string | string[]): T => {
   const omitKeys = typeof keys === 'string' ? [keys] : keys
   if (!Array.isArray(omitKeys)) return value
 
-  for (const key of omitKeys) {
-    unset(value, key)
-  }
+  const { topLevel, nested } = classifyKeys(omitKeys)
+  const result = {} as Record<string, unknown>
 
   for (const key of Object.keys(value)) {
-    ;(value as Record<string, unknown>)[key] = omitDeep((value as Record<string, unknown>)[key], omitKeys)
+    if (topLevel.has(key)) continue
+
+    const nestedKeys = nested.get(key)
+    result[key] = omitDeep((value as Record<string, unknown>)[key], nestedKeys ?? omitKeys)
   }
 
-  return value
+  return result as T
 }

package/src/patch.ts

@@ -11,45 +11,33 @@ const isPatchHistoryEnabled = <T>(opts: PluginOptions<T>, context: PatchContext<
   return !opts.patchHistoryDisabled && !context.ignorePatchHistory
 }
 
-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>
+const applyOmit = <T>(object: Partial<T>, opts: PluginOptions<T>): Partial<T> => {
+  return opts.omit ? omit(object, opts.omit) : object
+}
 
-  if (opts.omit) {
-    return omit(object, opts.omit)
-  }
+const replacer = (_key: string, value: unknown): unknown => (typeof value === 'bigint' ? value.toString() : value)
 
-  return object
+export const getJsonOmit = <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> => {
+  // NOSONAR — structuredClone cannot handle mongoose documents (they contain non-cloneable methods)
+  return applyOmit(JSON.parse(JSON.stringify(doc, replacer)) as Partial<T>, opts)
 }
 
 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)
-  }
-
-  return doc
+  return applyOmit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts)
 }
 
-export const getUser = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<User | undefined> => {
-  if (isFunction(opts.getUser)) {
-    return await opts.getUser(doc)
+const getOptionalField = async <T, R>(fn: ((doc: HydratedDocument<T>) => Promise<R> | R) | undefined, doc?: HydratedDocument<T>): Promise<R | undefined> => {
+  if (isFunction(fn)) {
+    return await fn(doc as HydratedDocument<T>)
   }
   return 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 const getUser = async <T>(opts: PluginOptions<T>, doc?: HydratedDocument<T>): Promise<User | undefined> => getOptionalField(opts.getUser, doc)
 
-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 const getReason = async <T>(opts: PluginOptions<T>, doc?: HydratedDocument<T>): Promise<string | undefined> => getOptionalField(opts.getReason, doc)
+
+export const getMetadata = async <T>(opts: PluginOptions<T>, doc?: HydratedDocument<T>): Promise<Metadata | undefined> => getOptionalField(opts.getMetadata, doc)
 
 export const getValue = <T>(item: PromiseSettledResult<T>): T | undefined => {
   return item.status === 'fulfilled' ? item.value : undefined
@@ -63,7 +51,11 @@ export const getData = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T
 
 export const emitEvent = <T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void => {
   if (event && !context.ignoreEvent) {
-    em.emit(event, data)
+    try {
+      em.emit(event, data)
+    } catch {
+      // Listener errors must not crash patch history recording
+    }
   }
 }
 
@@ -80,7 +72,8 @@ export const bulkPatch = async <T>(opts: PluginOptions<T>, context: PatchContext
     const bulk = []
 
     for (const doc of batch) {
-      emitEvent(context, event, { [key]: doc })
+      const omitted = getObjectOmit(opts, doc)
+      emitEvent(context, event, { [key]: omitted })
 
       if (history) {
         const [user, reason, metadata] = await getData(opts, doc)
@@ -91,7 +84,7 @@ export const bulkPatch = async <T>(opts: PluginOptions<T>, context: PatchContext
               modelName: context.modelName,
               collectionName: context.collectionName,
               collectionId: doc._id as Types.ObjectId,
-              doc: getObjectOmit(opts, doc),
+              doc: omitted,
               version: 0,
               ...(user !== undefined && { user }),
               ...(reason !== undefined && { reason }),
@@ -103,8 +96,9 @@ export const bulkPatch = async <T>(opts: PluginOptions<T>, context: PatchContext
     }
 
     if (history && !isEmpty(bulk)) {
+      const onError = opts.onError ?? console.error
       await HistoryModel.bulkWrite(bulk, { ordered: false }).catch((error: MongooseError) => {
-        console.error(error.message)
+        onError(error)
       })
     }
   }
@@ -138,6 +132,7 @@ export const updatePatch = async <T>(opts: PluginOptions<T>, context: PatchConte
     }
 
     const [user, reason, metadata] = await getData(opts, current)
+    const onError = opts.onError ?? console.error
     await HistoryModel.create({
       op: context.op,
       modelName: context.modelName,
@@ -148,6 +143,8 @@ export const updatePatch = async <T>(opts: PluginOptions<T>, context: PatchConte
       ...(user !== undefined && { user }),
       ...(reason !== undefined && { reason }),
       ...(metadata !== undefined && { metadata }),
+    }).catch((error: MongooseError) => {
+      onError(error)
     })
   }
 }

package/src/types.ts

@@ -49,4 +49,5 @@ export interface PluginOptions<T> {
   omit?: string[]
   patchHistoryDisabled?: boolean
   preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>
+  onError?: (error: Error) => void
 }

package/tests/em.test.ts

@@ -1,10 +1,14 @@
-import { describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import { patchEventEmitter } from '../src/index'
 import { emitEvent } from '../src/patch'
 
 describe('em', () => {
-  it('should subscribe and count', async () => {
+  afterEach(() => {
+    patchEventEmitter.removeAllListeners()
+  })
+
+  it('should subscribe and count', () => {
     let count = 0
     const fn = () => {
       count++
@@ -17,7 +21,7 @@ describe('em', () => {
     expect(count).toBe(1)
   })
 
-  it('emitEvent', async () => {
+  it('emitEvent', () => {
     const fn = vi.fn()
     patchEventEmitter.on('test', fn)
 
@@ -29,12 +33,10 @@ describe('em', () => {
 
     // @ts-expect-error expected
     emitEvent(context, 'test', { doc: { name: 'test' } })
-    expect(fn).toHaveBeenCalledTimes(1)
-
-    patchEventEmitter.off('test', fn)
+    expect(fn).toHaveBeenCalledOnce()
   })
 
-  it('emitEvent ignore', async () => {
+  it('emitEvent ignore', () => {
     const fn = vi.fn()
     patchEventEmitter.on('test', fn)
 
@@ -48,7 +50,21 @@ describe('em', () => {
     // @ts-expect-error expected
     emitEvent(context, 'test', { doc: { name: 'test' } })
     expect(fn).toHaveBeenCalledTimes(0)
+  })
 
-    patchEventEmitter.off('test', fn)
+  it('emitEvent should not throw when listener throws', () => {
+    const fn = () => {
+      throw new Error('listener error')
+    }
+    patchEventEmitter.on('throw-test', fn)
+
+    const context = {
+      op: 'test',
+      modelName: 'Test',
+      collectionName: 'tests',
+    }
+
+    // @ts-expect-error expected
+    expect(() => emitEvent(context, 'throw-test', { doc: { name: 'test' } })).not.toThrow()
   })
 })

package/tests/helpers.test.ts

@@ -308,4 +308,66 @@ describe('cloneDeep', () => {
     expect(cloned.b).toEqual({ c: 2 })
     expect(cloned.b).not.toBe(original.b)
   })
+
+  it('should clone Error instances preserving message and stack', () => {
+    const original = new Error('test error')
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned).toBeInstanceOf(Error)
+    expect(cloned.message).toBe('test error')
+    expect(cloned.stack).toBe(original.stack)
+  })
+
+  it('should fall through to cloneCollection for partial BSON-like objects', () => {
+    const original = { _bsontype: 'SomeType', value: 42 }
+    const cloned = cloneDeep(original)
+    expect(cloned).toEqual({ _bsontype: 'SomeType', value: 42 })
+    expect(cloned).not.toBe(original)
+  })
+
+  it('should clone BSON-like objects via toHexString', () => {
+    const hex = '507f1f77bcf86cd799439011'
+    const original = {
+      _bsontype: 'ObjectId',
+      toHexString: () => hex,
+      toJSON: () => hex,
+    }
+    Object.setPrototypeOf(original, {
+      constructor: class ObjectId {
+        hex: string
+        constructor(h: string) {
+          this.hex = h
+        }
+        toHexString() {
+          return this.hex
+        }
+      },
+    })
+    const cloned = cloneDeep(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned.toHexString()).toBe(hex)
+  })
+})
+
+describe('setPatchHistoryTTL', () => {
+  it('should call custom onError handler on failure', async () => {
+    const indexes = HistoryModel.collection.indexes as Mock
+    indexes.mockRejectedValue(new Error('connection failed'))
+
+    const onError = vi.fn()
+    await setPatchHistoryTTL('1h', onError)
+
+    expect(onError).toHaveBeenCalledOnce()
+    expect(onError).toHaveBeenCalledWith(expect.any(Error))
+  })
+
+  it('should fall back to console.error when no onError provided', async () => {
+    const indexes = HistoryModel.collection.indexes as Mock
+    indexes.mockRejectedValue(new Error('connection failed'))
+
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    await setPatchHistoryTTL('1h')
+
+    expect(spy).toHaveBeenCalledOnce()
+  })
 })

package/tests/omit-deep.test.ts

@@ -109,9 +109,9 @@ describe('omitDeep', () => {
     expect(omitDeep(obj, ['a', 'c'])).toEqual({ b: 2, d: 4 })
   })
 
-  it('should not omit from dot-notation when value at path has no value', () => {
+  it('should omit from dot-notation even when value is empty', () => {
     const obj = { a: { b: '' } }
-    expect(omitDeep(obj, ['a.b'])).toEqual({ a: { b: '' } })
+    expect(omitDeep(obj, ['a.b'])).toEqual({ a: {} })
   })
 
   it('should omit dot-notation with nested value present', () => {
@@ -181,10 +181,9 @@ describe('omitDeep', () => {
     expect(omitDeep(obj, ['config.data'])).toEqual({ config: {} })
   })
 
-  it('should not unset empty Map at dot path (hasValue is false)', () => {
+  it('should unset empty Map at dot path', () => {
     const obj = { config: { data: new Map() } } as Record<string, unknown>
-    const result = omitDeep(obj, ['config.data'])
-    expect(result.config).toHaveProperty('data')
+    expect(omitDeep(obj, ['config.data'])).toEqual({ config: {} })
   })
 
   it('should unset non-empty Set at dot path', () => {
@@ -192,10 +191,9 @@ describe('omitDeep', () => {
     expect(omitDeep(obj, ['config.data'])).toEqual({ config: {} })
   })
 
-  it('should not unset empty Set at dot path (hasValue is false)', () => {
+  it('should unset empty Set at dot path', () => {
     const obj = { config: { data: new Set() } } as Record<string, unknown>
-    const result = omitDeep(obj, ['config.data'])
-    expect(result.config).toHaveProperty('data')
+    expect(omitDeep(obj, ['config.data'])).toEqual({ config: {} })
   })
 
   it('should handle null value at dot-notation intermediate', () => {
@@ -213,8 +211,25 @@ describe('omitDeep', () => {
     expect(omitDeep(obj, ['config.items'])).toEqual({ config: {} })
   })
 
-  it('should not unset empty array at dot path (hasValue is false)', () => {
+  it('should unset empty array at dot path', () => {
     const obj = { config: { items: [] } }
-    expect(omitDeep(obj, ['config.items'])).toEqual({ config: { items: [] } })
+    expect(omitDeep(obj, ['config.items'])).toEqual({ config: {} })
+  })
+
+  it('should not mutate the original object', () => {
+    const obj = { a: 1, b: 2, nested: { c: 3, d: 4 } }
+    const original = structuredClone(obj)
+    omitDeep(obj, ['b', 'nested.c'])
+    expect(obj).toEqual(original)
+  })
+
+  it('should not mutate the original array', () => {
+    const arr = [
+      { a: 1, b: 2 },
+      { a: 3, b: 4 },
+    ]
+    const original = structuredClone(arr)
+    omitDeep(arr, ['b'])
+    expect(arr).toEqual(original)
   })
 })

package/tests/patch.test.ts

@@ -1,6 +1,5 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { afterEach } from 'node:test'
 import mongoose from 'mongoose'
 import em from '../src/em'
 import { patchHistoryPlugin } from '../src/index'
@@ -37,8 +36,8 @@ describe('patch tests', () => {
     await mongoose.connection.collection('patches').deleteMany({})
   })
 
-  afterEach(async () => {
-    vi.clearAllMocks()
+  afterEach(() => {
+    vi.resetAllMocks()
   })
 
   describe('getObjects', () => {
@@ -125,6 +124,8 @@ describe('patch tests', () => {
     it('should return if one object is empty', async () => {
       const current = await UserModel.create({ name: 'John', role: 'user' })
 
+      vi.clearAllMocks()
+
       const pluginOptions: PluginOptions<User> = {
         eventDeleted: USER_DELETED,
         patchHistoryDisabled: true,
@@ -137,7 +138,7 @@ describe('patch tests', () => {
       }
 
       await updatePatch(pluginOptions, context, current, {} as HydratedDocument<User>)
-      expect(em.emit).toHaveBeenCalled()
+      expect(em.emit).not.toHaveBeenCalled()
     })
   })
 

package/tests/plugin-all-features.test.ts

@@ -149,7 +149,7 @@ describe('plugin — all features', () => {
     expect(entry.doc).not.toHaveProperty('__v')
   })
 
-  it('should omit specified fields from update patches', async () => {
+  it('should produce no update history when only omitted fields change', async () => {
     const order = await OrderModel.create({
       item: 'Widget',
       quantity: 10,
@@ -660,6 +660,7 @@ describe('plugin — all features', () => {
       },
     })
 
+    if (mongoose.models.ThrowOrder) mongoose.deleteModel('ThrowOrder')
     const ThrowModel = model<Order>('ThrowOrder', ThrowSchema)
 
     const doc = await ThrowModel.create({
@@ -721,6 +722,7 @@ describe('plugin — all features', () => {
       omit: ['__v', 'createdAt', 'updatedAt'],
     })
 
+    if (mongoose.models.DeepDoc) mongoose.deleteModel('DeepDoc')
     const DeepModel = model('DeepDoc', DeepSchema)
 
     const doc = await DeepModel.create({
@@ -738,4 +740,105 @@ describe('plugin — all features', () => {
     expect(paths).toContain('/config/settings/theme')
     expect(paths).toContain('/config/settings/notifications')
   })
+
+  it('should not crash when post-hook runs after ignoreHook skipped pre-hook (update)', async () => {
+    const order = await OrderModel.create({
+      item: 'GuardTest',
+      quantity: 1,
+      tags: [],
+      address: { street: '1 St', city: 'G', zip: '00000' },
+    })
+
+    await OrderModel.updateOne({ _id: order._id }, { quantity: 5 }).setOptions({ ignoreHook: true }).exec()
+
+    await OrderModel.updateOne({ _id: order._id }, { quantity: 10 }).exec()
+
+    const updates = await HistoryModel.find({ op: 'updateOne', collectionId: order._id })
+    expect(updates).toHaveLength(1)
+    expect(updates[0]?.patch).toMatchObject(expect.arrayContaining([expect.objectContaining({ op: 'replace', path: '/quantity' })]))
+  })
+
+  it('should not crash when post-hook runs after ignoreHook skipped pre-hook (delete)', async () => {
+    const order = await OrderModel.create({
+      item: 'GuardDelete',
+      quantity: 1,
+      tags: [],
+      address: { street: '1 St', city: 'G', zip: '00000' },
+    })
+
+    await OrderModel.deleteOne({ _id: order._id }).setOptions({ ignoreHook: true }).exec()
+
+    const history = await HistoryModel.find({ collectionId: order._id })
+    expect(history).toHaveLength(1)
+    expect(history[0]?.op).toBe('create')
+  })
+
+  it('should call onError when bulkWrite fails during create', async () => {
+    const onError = vi.fn()
+
+    const ErrorSchema = new Schema<Order>(
+      {
+        item: { type: String, required: true },
+        quantity: { type: Number, required: true },
+        tags: { type: [String], default: undefined },
+        address: { type: AddressSchema, required: true },
+      },
+      { timestamps: true },
+    )
+
+    ErrorSchema.plugin(patchHistoryPlugin, {
+      omit: ['__v', 'createdAt', 'updatedAt'],
+      onError,
+    })
+
+    if (mongoose.models.ErrorOrder) mongoose.deleteModel('ErrorOrder')
+    const ErrorModel = model<Order>('ErrorOrder', ErrorSchema)
+
+    vi.spyOn(HistoryModel, 'bulkWrite').mockRejectedValueOnce(new Error('bulkWrite failed'))
+
+    await ErrorModel.create({
+      item: 'BulkErr',
+      quantity: 1,
+      tags: [],
+      address: { street: '1 St', city: 'E', zip: '00000' },
+    })
+
+    expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'bulkWrite failed' }))
+  })
+
+  it('should call onError when create fails during update', async () => {
+    const onError = vi.fn()
+
+    const ErrorSchema2 = new Schema<Order>(
+      {
+        item: { type: String, required: true },
+        quantity: { type: Number, required: true },
+        tags: { type: [String], default: undefined },
+        address: { type: AddressSchema, required: true },
+      },
+      { timestamps: true },
+    )
+
+    ErrorSchema2.plugin(patchHistoryPlugin, {
+      omit: ['__v', 'createdAt', 'updatedAt'],
+      onError,
+    })
+
+    if (mongoose.models.ErrorOrder2) mongoose.deleteModel('ErrorOrder2')
+    const ErrorModel2 = model<Order>('ErrorOrder2', ErrorSchema2)
+
+    const doc = await ErrorModel2.create({
+      item: 'CreateErr',
+      quantity: 1,
+      tags: [],
+      address: { street: '1 St', city: 'E', zip: '00000' },
+    })
+
+    onError.mockClear()
+    vi.spyOn(HistoryModel, 'create').mockRejectedValueOnce(new Error('create failed') as never)
+
+    await ErrorModel2.updateOne({ _id: doc._id }, { quantity: 99 }).exec()
+
+    expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'create failed' }))
+  })
 })