ts-patch-mongoose 3.1.0 → 4.0.0

package/src/patch.ts

@@ -1,154 +0,0 @@
-import jsonpatch from 'fast-json-patch'
-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'
-
-const isPatchHistoryEnabled = <T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean => {
-  return !opts.patchHistoryDisabled && !context.ignorePatchHistory
-}
-
-const applyOmit = <T>(object: Partial<T>, opts: PluginOptions<T>): Partial<T> => {
-  return opts.omit ? omit(object, opts.omit) : object
-}
-
-const replacer = (_key: string, value: unknown): unknown => (typeof value === 'bigint' ? value.toString() : value)
-
-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> => {
-  return applyOmit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts)
-}
-
-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 getUser = async <T>(opts: PluginOptions<T>, doc?: HydratedDocument<T>): Promise<User | undefined> => getOptionalField(opts.getUser, doc)
-
-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
-}
-
-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 const emitEvent = <T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void => {
-  if (event && !context.ignoreEvent) {
-    try {
-      em.emit(event, data)
-    } catch {
-      // Listener errors must not crash patch history recording
-    }
-  }
-}
-
-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) || !docs || (!event && !history)) return
-
-  const chunks = chunk(docs, 1000)
-  for (const batch of chunks) {
-    const bulk = []
-
-    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({
-          insertOne: {
-            document: {
-              op: context.op,
-              modelName: context.modelName,
-              collectionName: context.collectionName,
-              collectionId: doc._id as Types.ObjectId,
-              doc: omitted,
-              version: 0,
-              ...(user !== undefined && { user }),
-              ...(reason !== undefined && { reason }),
-              ...(metadata !== undefined && { metadata }),
-            },
-          },
-        })
-      }
-    }
-
-    if (history && !isEmpty(bulk)) {
-      const onError = opts.onError ?? console.error
-      await HistoryModel.bulkWrite(bulk, { ordered: false }).catch((error: MongooseError) => {
-        onError(error)
-      })
-    }
-  }
-}
-
-export const createPatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
-  await bulkPatch(opts, context, 'eventCreated', 'createdDocs')
-}
-
-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)
-  const originalObject = getJsonOmit(opts, original)
-  if (isEmpty(originalObject) || isEmpty(currentObject)) return
-
-  const patch = jsonpatch.compare(originalObject, currentObject, true)
-  if (isEmpty(patch)) return
-
-  emitEvent(context, opts.eventUpdated, { oldDoc: original, doc: current, patch })
-
-  if (history) {
-    let version = 0
-
-    const lastHistory = await HistoryModel.findOne({ collectionId: original._id as Types.ObjectId })
-      .sort('-version')
-      .exec()
-
-    if (lastHistory && lastHistory.version >= 0) {
-      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,
-      collectionName: context.collectionName,
-      collectionId: original._id as Types.ObjectId,
-      patch,
-      version,
-      ...(user !== undefined && { user }),
-      ...(reason !== undefined && { reason }),
-      ...(metadata !== undefined && { metadata }),
-    }).catch((error: MongooseError) => {
-      onError(error)
-    })
-  }
-}
-
-export const deletePatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
-  await bulkPatch(opts, context, 'eventDeleted', 'deletedDocs')
-}

package/src/types.ts

@@ -1,53 +0,0 @@
-import type { Operation } from 'fast-json-patch'
-import type { HydratedDocument, Query, Types } from 'mongoose'
-
-export interface History {
-  op: string
-  modelName: string
-  collectionName: string
-  collectionId: Types.ObjectId
-  version: number
-  doc?: object
-  user?: object
-  reason?: string
-  metadata?: object
-  patch?: Operation[]
-}
-
-export interface PatchEvent<T> {
-  oldDoc?: HydratedDocument<T>
-  doc?: HydratedDocument<T>
-  patch?: Operation[]
-}
-
-export interface PatchContext<T> {
-  op: string
-  modelName: string
-  collectionName: string
-  isNew?: boolean
-  createdDocs?: HydratedDocument<T>[]
-  deletedDocs?: HydratedDocument<T>[]
-  ignoreEvent?: boolean
-  ignorePatchHistory?: boolean
-}
-
-export type HookContext<T> = Query<T, T> & { op: string; _context: PatchContext<T> }
-
-export type User = Record<string, unknown>
-
-export type Metadata = Record<string, unknown>
-
-export interface PluginOptions<T> {
-  modelName?: string
-  collectionName?: string
-  eventUpdated?: string
-  eventCreated?: string
-  eventDeleted?: string
-  getUser?: (doc: HydratedDocument<T>) => Promise<User> | User
-  getReason?: (doc: HydratedDocument<T>) => Promise<string> | string
-  getMetadata?: (doc: HydratedDocument<T>) => Promise<Metadata> | Metadata
-  omit?: string[]
-  patchHistoryDisabled?: boolean
-  preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>
-  onError?: (error: Error) => void
-}

package/src/version.ts

@@ -1,13 +0,0 @@
-import mongoose from 'mongoose'
-
-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) {
-  mongoose.set('strictQuery', false)
-}
-/* v8 ignore end */

package/tests/constants/events.ts

@@ -1,7 +0,0 @@
-export const USER_CREATED = 'user-created'
-export const USER_UPDATED = 'user-updated'
-export const USER_DELETED = 'user-deleted'
-
-export const GLOBAL_CREATED = 'global-created'
-export const GLOBAL_UPDATED = 'global-updated'
-export const GLOBAL_DELETED = 'global-deleted'

package/tests/em.test.ts

@@ -1,70 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { patchEventEmitter } from '../src/index'
-import { emitEvent } from '../src/patch'
-
-describe('em', () => {
-  afterEach(() => {
-    patchEventEmitter.removeAllListeners()
-  })
-
-  it('should subscribe and count', () => {
-    let count = 0
-    const fn = () => {
-      count++
-    }
-    patchEventEmitter.on('test', fn)
-    patchEventEmitter.emit('test')
-    expect(count).toBe(1)
-    patchEventEmitter.off('test', fn)
-    patchEventEmitter.emit('test')
-    expect(count).toBe(1)
-  })
-
-  it('emitEvent', () => {
-    const fn = vi.fn()
-    patchEventEmitter.on('test', fn)
-
-    const context = {
-      op: 'test',
-      modelName: 'Test',
-      collectionName: 'tests',
-    }
-
-    // @ts-expect-error expected
-    emitEvent(context, 'test', { doc: { name: 'test' } })
-    expect(fn).toHaveBeenCalledOnce()
-  })
-
-  it('emitEvent ignore', () => {
-    const fn = vi.fn()
-    patchEventEmitter.on('test', fn)
-
-    const context = {
-      ignoreEvent: true,
-      op: 'test',
-      modelName: 'Test',
-      collectionName: 'tests',
-    }
-
-    // @ts-expect-error expected
-    emitEvent(context, 'test', { doc: { name: 'test' } })
-    expect(fn).toHaveBeenCalledTimes(0)
-  })
-
-  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

@@ -1,373 +0,0 @@
-import type { Mock, MockInstance } from 'vitest'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { cloneDeep, isEmpty, setPatchHistoryTTL } from '../src/helpers'
-import { HistoryModel } from '../src/model'
-import { ms } from '../src/ms'
-
-vi.mock('../src/model', () => ({
-  HistoryModel: {
-    collection: {
-      indexes: vi.fn(),
-      dropIndex: vi.fn(),
-      createIndex: vi.fn(),
-    },
-  },
-}))
-
-const name = 'createdAt_1_TTL'
-
-describe('useTTL', () => {
-  let dropIndexSpy: MockInstance
-  let createIndexSpy: MockInstance
-  const indexes = HistoryModel.collection.indexes as Mock
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    dropIndexSpy = vi.spyOn(HistoryModel.collection, 'dropIndex')
-    createIndexSpy = vi.spyOn(HistoryModel.collection, 'createIndex')
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('should drop the index if historyTTL is not set and index exists', async () => {
-    indexes.mockResolvedValue([{ name }])
-
-    // @ts-expect-error ttl can't be undefined in this case but we want to test it
-    await setPatchHistoryTTL(undefined)
-    expect(dropIndexSpy).toHaveBeenCalledWith(name)
-  })
-
-  it('should drop the index if historyTTL is less than 1 second and index exists', async () => {
-    indexes.mockResolvedValue([{ name }])
-
-    await setPatchHistoryTTL('500ms')
-    expect(dropIndexSpy).toHaveBeenCalledWith(name)
-  })
-
-  it('should not recreate the index if it already exists with the correct TTL', async () => {
-    const ttl = '1h'
-    const expireAfterSeconds = ms(ttl) / 1000
-
-    indexes.mockResolvedValue([{ name, expireAfterSeconds }])
-
-    await setPatchHistoryTTL(ttl)
-    expect(dropIndexSpy).not.toHaveBeenCalled()
-    expect(createIndexSpy).not.toHaveBeenCalled()
-  })
-
-  it('should drop and recreate the index if TTL is different', async () => {
-    const ttlBefore = '1h'
-    const ttlAfter = '2h'
-
-    const expireAfterSecondsBefore = ms(ttlBefore) / 1000
-    const expireAfterSecondsAfter = ms(ttlAfter) / 1000
-
-    indexes.mockResolvedValue([{ name, expireAfterSeconds: expireAfterSecondsBefore }])
-
-    await setPatchHistoryTTL(ttlAfter)
-    expect(dropIndexSpy).toHaveBeenCalledWith(name)
-    expect(createIndexSpy).toHaveBeenCalledWith({ createdAt: 1 }, { expireAfterSeconds: expireAfterSecondsAfter, name })
-  })
-
-  it('should create the index if it does not exist', async () => {
-    const ttl = '1h'
-    const expireAfterSeconds = ms(ttl) / 1000
-
-    indexes.mockResolvedValue([])
-
-    await setPatchHistoryTTL(ttl)
-    expect(createIndexSpy).toHaveBeenCalledWith({ createdAt: 1 }, { expireAfterSeconds, name })
-  })
-})
-
-describe('isEmpty', () => {
-  it('should return true for null and undefined', () => {
-    expect(isEmpty(null)).toBe(true)
-    expect(isEmpty(undefined)).toBe(true)
-  })
-
-  it('should return true for empty arrays and strings', () => {
-    expect(isEmpty([])).toBe(true)
-    expect(isEmpty('')).toBe(true)
-  })
-
-  it('should return false for non-empty arrays and strings', () => {
-    expect(isEmpty([1, 2])).toBe(false)
-    expect(isEmpty('hello')).toBe(false)
-  })
-
-  it('should return true for empty objects', () => {
-    expect(isEmpty({})).toBe(true)
-  })
-
-  it('should return false for non-empty objects', () => {
-    expect(isEmpty({ a: 1 })).toBe(false)
-  })
-
-  it('should return true for empty Map and Set', () => {
-    expect(isEmpty(new Map())).toBe(true)
-    expect(isEmpty(new Set())).toBe(true)
-  })
-
-  it('should return false for non-empty Map and Set', () => {
-    expect(isEmpty(new Map([['a', 1]]))).toBe(false)
-    expect(isEmpty(new Set([1]))).toBe(false)
-  })
-
-  it('should return true for numbers, booleans, and functions (matches lodash)', () => {
-    expect(isEmpty(0)).toBe(true)
-    expect(isEmpty(1)).toBe(true)
-    expect(isEmpty(true)).toBe(true)
-    expect(isEmpty(false)).toBe(true)
-    expect(isEmpty(() => {})).toBe(true)
-  })
-
-  it('should return true for Date and RegExp (matches lodash)', () => {
-    expect(isEmpty(new Date())).toBe(true)
-    expect(isEmpty(/test/)).toBe(true)
-  })
-})
-
-describe('cloneDeep', () => {
-  it('should clone primitives', () => {
-    expect(cloneDeep(42)).toBe(42)
-    expect(cloneDeep('hello')).toBe('hello')
-    expect(cloneDeep(null)).toBe(null)
-    expect(cloneDeep(undefined)).toBe(undefined)
-    expect(cloneDeep(true)).toBe(true)
-  })
-
-  it('should deep clone plain objects', () => {
-    const original = { a: 1, b: { c: 2 } }
-    const cloned = cloneDeep(original)
-    expect(cloned).toEqual(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.b).not.toBe(original.b)
-  })
-
-  it('should deep clone arrays', () => {
-    const original = [1, [2, 3], { a: 4 }]
-    const cloned = cloneDeep(original)
-    expect(cloned).toEqual(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned[1]).not.toBe(original[1])
-    expect(cloned[2]).not.toBe(original[2])
-  })
-
-  it('should clone Date instances', () => {
-    const original = new Date('2026-01-01')
-    const cloned = cloneDeep(original)
-    expect(cloned).toEqual(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.getTime()).toBe(original.getTime())
-  })
-
-  it('should clone RegExp instances', () => {
-    const original = /test/gi
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.source).toBe(original.source)
-    expect(cloned.flags).toBe(original.flags)
-  })
-
-  it('should clone Map instances', () => {
-    const original = new Map([['a', { nested: 1 }]])
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.get('a')).toEqual({ nested: 1 })
-    expect(cloned.get('a')).not.toBe(original.get('a'))
-  })
-
-  it('should clone Set instances', () => {
-    const obj = { a: 1 }
-    const original = new Set([obj])
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.size).toBe(1)
-    const [clonedItem] = cloned
-    expect(clonedItem).toEqual(obj)
-    expect(clonedItem).not.toBe(obj)
-  })
-
-  it('should handle circular references in objects', () => {
-    const original: Record<string, unknown> = { a: 1 }
-    original.self = original
-    const cloned = cloneDeep(original)
-    expect(cloned.a).toBe(1)
-    expect(cloned.self).toBe(cloned)
-    expect(cloned).not.toBe(original)
-  })
-
-  it('should handle circular references in arrays', () => {
-    const original: unknown[] = [1, 2]
-    original.push(original)
-    const cloned = cloneDeep(original)
-    expect(cloned[0]).toBe(1)
-    expect(cloned[1]).toBe(2)
-    expect(cloned[2]).toBe(cloned)
-    expect(cloned).not.toBe(original)
-  })
-
-  it('should handle circular references in nested objects', () => {
-    const child: Record<string, unknown> = { value: 'child' }
-    const parent: Record<string, unknown> = { child }
-    child.parent = parent
-    const cloned = cloneDeep(parent)
-    expect(cloned).not.toBe(parent)
-    expect(cloned.child).not.toBe(child)
-    expect((cloned.child as Record<string, unknown>).value).toBe('child')
-    expect((cloned.child as Record<string, unknown>).parent).toBe(cloned)
-  })
-
-  it('should handle circular references in Maps', () => {
-    const original = new Map<string, unknown>()
-    original.set('self', original)
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.get('self')).toBe(cloned)
-  })
-
-  it('should handle circular references in Sets', () => {
-    const original = new Set<unknown>()
-    original.add(original)
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.has(cloned)).toBe(true)
-    expect(cloned.size).toBe(1)
-  })
-
-  it('should clone objects with toJSON method via JSON round-trip', () => {
-    const original = { value: 42, toJSON: () => ({ value: 42 }) }
-    const cloned = cloneDeep(original)
-    expect(cloned).toEqual({ value: 42 })
-    expect(cloned).not.toBe(original)
-  })
-
-  it('should clone ArrayBuffer', () => {
-    const original = new ArrayBuffer(8)
-    new Uint8Array(original).set([1, 2, 3, 4, 5, 6, 7, 8])
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.byteLength).toBe(8)
-    expect(new Uint8Array(cloned)).toEqual(new Uint8Array(original))
-  })
-
-  it('should clone DataView', () => {
-    const buffer = new ArrayBuffer(16)
-    const original = new DataView(buffer, 4, 8)
-    original.setInt32(0, 42)
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.buffer).not.toBe(original.buffer)
-    expect(cloned.byteOffset).toBe(4)
-    expect(cloned.byteLength).toBe(8)
-    expect(cloned.getInt32(0)).toBe(42)
-  })
-
-  it('should clone TypedArrays with offset and length', () => {
-    const buffer = new ArrayBuffer(16)
-    const original = new Uint8Array(buffer, 4, 8)
-    original.set([10, 20, 30, 40, 50, 60, 70, 80])
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.buffer).not.toBe(original.buffer)
-    expect(cloned.byteOffset).toBe(4)
-    expect(cloned.length).toBe(8)
-    expect(Array.from(cloned)).toEqual([10, 20, 30, 40, 50, 60, 70, 80])
-  })
-
-  it('should clone Float64Array', () => {
-    const original = new Float64Array([1.1, 2.2, 3.3])
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.buffer).not.toBe(original.buffer)
-    expect(Array.from(cloned)).toEqual([1.1, 2.2, 3.3])
-  })
-
-  it('should clone RegExp with lastIndex', () => {
-    const original = /foo/g
-    original.exec('foobar')
-    expect(original.lastIndex).toBe(3)
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.lastIndex).toBe(3)
-    expect(cloned.source).toBe('foo')
-    expect(cloned.flags).toBe('g')
-  })
-
-  it('should clone object without constructor', () => {
-    const original = Object.create(null) as Record<string, unknown>
-    original.a = 1
-    original.b = { c: 2 }
-    const cloned = cloneDeep(original)
-    expect(cloned).not.toBe(original)
-    expect(cloned.a).toBe(1)
-    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/mongo/.gitignore

@@ -1,3 +0,0 @@
-*
-!.gitignore
-!server.ts