ts-patch-mongoose 3.1.0 → 3.1.2

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

package/tests/mongo/server.ts

@@ -1,31 +0,0 @@
-import fs from 'node:fs'
-import { MongoMemoryServer } from 'mongodb-memory-server'
-import mongoose from 'mongoose'
-
-const server = (dbName: string) => {
-  let mongo: MongoMemoryServer
-  const dbPath = `./tests/mongo/${dbName}`
-
-  const create = async () => {
-    fs.mkdirSync(dbPath, { recursive: true })
-    mongo = await MongoMemoryServer.create({
-      instance: {
-        dbName,
-        dbPath,
-      },
-    })
-
-    const uri = mongo.getUri()
-    await mongoose.connect(uri)
-  }
-
-  const destroy = async () => {
-    await mongoose.connection.dropDatabase()
-    await mongoose.connection.close()
-    await mongo.stop({ doCleanup: true, force: true })
-  }
-
-  return { create, destroy }
-}
-
-export default server

package/tests/ms.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { ms, UNITS } from '../src/ms'
-
-const { s, m, h, d, w, mo, y } = UNITS
-
-describe('ms', () => {
-  it('should parse milliseconds', () => {
-    expect(ms('100ms')).toBe(100)
-    expect(ms('500msecs')).toBe(500)
-    expect(ms('1millisecond')).toBe(1)
-    expect(ms('5milliseconds')).toBe(5)
-  })
-
-  it('should parse seconds', () => {
-    expect(ms('1s')).toBe(s)
-    expect(ms('5sec')).toBe(5 * s)
-    expect(ms('10secs')).toBe(10 * s)
-    expect(ms('1second')).toBe(s)
-    expect(ms('2seconds')).toBe(2 * s)
-  })
-
-  it('should parse minutes', () => {
-    expect(ms('1m')).toBe(m)
-    expect(ms('5min')).toBe(5 * m)
-    expect(ms('10mins')).toBe(10 * m)
-    expect(ms('1minute')).toBe(m)
-    expect(ms('2minutes')).toBe(2 * m)
-  })
-
-  it('should parse hours', () => {
-    expect(ms('1h')).toBe(h)
-    expect(ms('2hr')).toBe(2 * h)
-    expect(ms('3hrs')).toBe(3 * h)
-    expect(ms('1hour')).toBe(h)
-    expect(ms('2hours')).toBe(2 * h)
-  })
-
-  it('should parse days', () => {
-    expect(ms('1d')).toBe(d)
-    expect(ms('1day')).toBe(d)
-    expect(ms('2days')).toBe(2 * d)
-  })
-
-  it('should parse weeks', () => {
-    expect(ms('1w')).toBe(w)
-    expect(ms('1week')).toBe(w)
-    expect(ms('2weeks')).toBe(2 * w)
-  })
-
-  it('should parse months', () => {
-    expect(ms('1mo')).toBe(mo)
-    expect(ms('1month')).toBe(mo)
-    expect(ms('2months')).toBe(2 * mo)
-    expect(ms('6mo')).toBe(6 * mo)
-    expect(ms('0.5mo')).toBe(0.5 * mo)
-  })
-
-  it('should parse years', () => {
-    expect(ms('1y')).toBe(y)
-    expect(ms('1yr')).toBe(y)
-    expect(ms('1year')).toBe(y)
-    expect(ms('2years')).toBe(2 * y)
-  })
-
-  it('should default to milliseconds when no unit', () => {
-    expect(ms('500')).toBe(500)
-  })
-
-  it('should handle decimal values', () => {
-    expect(ms('1.5h')).toBe(1.5 * h)
-    expect(ms('0.5d')).toBe(0.5 * d)
-  })
-
-  it('should handle negative values', () => {
-    expect(ms('-1s')).toBe(-s)
-    expect(ms('-500ms')).toBe(-500)
-  })
-
-  it('should handle spaces between number and unit', () => {
-    expect(ms('1 hour')).toBe(h)
-    expect(ms('2  days')).toBe(2 * d)
-    expect(ms('500 ms')).toBe(500)
-    expect(ms('30 seconds')).toBe(30 * s)
-    expect(ms('5 min')).toBe(5 * m)
-    expect(ms('1 mo')).toBe(mo)
-    expect(ms('1 week')).toBe(w)
-    expect(ms('1 year')).toBe(y)
-  })
-
-  it('should be case insensitive', () => {
-    // @ts-expect-error runtime check
-    expect(ms('1H')).toBe(h)
-    // @ts-expect-error runtime check
-    expect(ms('1D')).toBe(d)
-    // @ts-expect-error runtime check
-    expect(ms('1MS')).toBe(1)
-  })
-
-  it('should return NaN for strings over 100 chars', () => {
-    // @ts-expect-error testing invalid input
-    expect(ms('a'.repeat(101))).toBeNaN()
-  })
-
-  it('should return NaN for invalid strings', () => {
-    // @ts-expect-error testing invalid input
-    expect(ms('abc')).toBeNaN()
-    // @ts-expect-error testing invalid input
-    expect(ms('')).toBeNaN()
-    // @ts-expect-error testing invalid input
-    expect(ms('hello world')).toBeNaN()
-  })
-})