ts-patch-mongoose 2.9.5 → 3.0.0

package/tests/helpers.test.ts

@@ -1,9 +1,9 @@
 import type { Mock, MockInstance } from 'vitest'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import ms from 'ms'
-import { setPatchHistoryTTL } from '../src/helpers'
+import { cloneDeep, isEmpty, setPatchHistoryTTL } from '../src/helpers'
 import { HistoryModel } from '../src/model'
+import { ms } from '../src/ms'
 
 vi.mock('../src/model', () => ({
   HistoryModel: {
@@ -82,3 +82,230 @@ describe('useTTL', () => {
     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)
+  })
+})

package/tests/ms.test.ts

@@ -0,0 +1,113 @@
+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()
+  })
+})

package/tests/omit-deep.test.ts

@@ -0,0 +1,220 @@
+import { describe, expect, it } from 'vitest'
+
+import { omitDeep } from '../src/omit-deep'
+
+describe('omitDeep', () => {
+  it('should return empty object for undefined', () => {
+    expect(omitDeep(undefined, 'a')).toEqual({})
+  })
+
+  it('should return primitives as-is', () => {
+    expect(omitDeep(42 as unknown, 'a')).toBe(42)
+    expect(omitDeep('hello' as unknown, 'a')).toBe('hello')
+    expect(omitDeep(null as unknown, 'a')).toBe(null)
+  })
+
+  it('should omit top-level keys', () => {
+    const obj = { a: 1, b: 2, c: 3 }
+    expect(omitDeep(obj, ['b'])).toEqual({ a: 1, c: 3 })
+  })
+
+  it('should omit with a single string key', () => {
+    const obj = { a: 1, b: 2 }
+    expect(omitDeep(obj, 'b')).toEqual({ a: 1 })
+  })
+
+  it('should omit nested keys recursively', () => {
+    const obj = { a: 1, nested: { a: 2, b: 3 } }
+    expect(omitDeep(obj, ['a'])).toEqual({ nested: { b: 3 } })
+  })
+
+  it('should handle arrays of objects', () => {
+    const arr = [
+      { a: 1, b: 2 },
+      { a: 3, b: 4 },
+    ]
+    expect(omitDeep(arr, ['a'])).toEqual([{ b: 2 }, { b: 4 }])
+  })
+
+  it('should handle deeply nested structures', () => {
+    const obj = { level1: { level2: { level3: { secret: 'hidden', keep: 'visible' } } } }
+    expect(omitDeep(obj, ['secret'])).toEqual({ level1: { level2: { level3: { keep: 'visible' } } } })
+  })
+
+  it('should support dot-notation paths', () => {
+    const obj = { address: { street: '123 Main', city: 'Springfield' }, name: 'John' }
+    expect(omitDeep(obj, ['address.street'])).toEqual({ address: { city: 'Springfield' }, name: 'John' })
+  })
+
+  it('should handle dot-notation with nested arrays', () => {
+    const obj = { config: { items: [{ secret: 1 }] }, meta: { secret: 2 } }
+    expect(omitDeep(obj, ['secret'])).toEqual({ config: { items: [{}] }, meta: {} })
+  })
+
+  it('should block __proto__ in dot-notation paths', () => {
+    const obj = { a: { b: 1 } }
+    omitDeep(obj, ['__proto__.polluted'])
+    expect(({} as Record<string, unknown>).polluted).toBeUndefined()
+  })
+
+  it('should block constructor in dot-notation paths', () => {
+    const obj = { a: 1 }
+    omitDeep(obj, ['constructor.something'])
+    expect(obj).toEqual({ a: 1 })
+  })
+
+  it('should block prototype in dot-notation paths', () => {
+    const obj = { a: 1 }
+    omitDeep(obj, ['prototype.something'])
+    expect(obj).toEqual({ a: 1 })
+  })
+
+  it('should return value if keys is not an array or string', () => {
+    const obj = { a: 1 }
+    expect(omitDeep(obj, 123 as unknown as string[])).toEqual({ a: 1 })
+  })
+
+  it('should handle non-plain objects', () => {
+    const date = new Date()
+    expect(omitDeep(date as unknown, 'a')).toBe(date)
+  })
+
+  it('should handle empty objects', () => {
+    expect(omitDeep({}, ['a'])).toEqual({})
+  })
+
+  it('should handle empty arrays', () => {
+    expect(omitDeep([], ['a'])).toEqual([])
+  })
+
+  it('should handle dot-notation where intermediate path is missing', () => {
+    const obj = { a: 1 }
+    expect(omitDeep(obj, ['x.y.z'])).toEqual({ a: 1 })
+  })
+
+  it('should handle dot-notation where intermediate is not an object', () => {
+    const obj = { a: 'string' }
+    expect(omitDeep(obj, ['a.b'])).toEqual({ a: 'string' })
+  })
+
+  it('should handle objects with null prototype', () => {
+    const obj = Object.create(null) as Record<string, unknown>
+    obj.a = 1
+    obj.b = 2
+    expect(omitDeep(obj, ['b'])).toEqual({ a: 1 })
+  })
+
+  it('should handle multiple keys at once', () => {
+    const obj = { a: 1, b: 2, c: 3, d: 4 }
+    expect(omitDeep(obj, ['a', 'c'])).toEqual({ b: 2, d: 4 })
+  })
+
+  it('should not omit from dot-notation when value at path has no value', () => {
+    const obj = { a: { b: '' } }
+    expect(omitDeep(obj, ['a.b'])).toEqual({ a: { b: '' } })
+  })
+
+  it('should omit dot-notation with nested value present', () => {
+    const obj = { a: { b: { c: 1 } } }
+    expect(omitDeep(obj, ['a.b.c'])).toEqual({ a: { b: {} } })
+  })
+
+  it('should handle object where nested values are all empty', () => {
+    const obj = { a: { b: {}, c: '' } }
+    expect(omitDeep(obj, ['x'])).toEqual({ a: { b: {}, c: '' } })
+  })
+
+  it('should handle object with RegExp values', () => {
+    const obj = { pattern: /test/i, name: 'hello' }
+    expect(omitDeep(obj, ['name'])).toEqual({ pattern: /test/i })
+  })
+
+  it('should handle object with Error values', () => {
+    const err = new Error('test error')
+    const obj = { error: err, name: 'hello' }
+    const result = omitDeep(obj, ['name'])
+    expect(result).toEqual({ error: err })
+  })
+
+  it('should handle object with Map values', () => {
+    const map = new Map([['key', 'value']])
+    const obj = { data: map, name: 'hello' } as Record<string, unknown>
+    const result = omitDeep(obj, ['name'])
+    expect(result.data).toBe(map)
+  })
+
+  it('should handle object with Set values', () => {
+    const set = new Set([1, 2, 3])
+    const obj = { data: set, name: 'hello' } as Record<string, unknown>
+    const result = omitDeep(obj, ['name'])
+    expect(result.data).toBe(set)
+  })
+
+  it('should handle object with boolean and number values at dot path', () => {
+    const obj = { config: { enabled: true, count: 0 } }
+    expect(omitDeep(obj, ['config.enabled'])).toEqual({ config: { count: 0 } })
+  })
+
+  it('should handle object with function values at dot path', () => {
+    const fn = () => 42
+    const obj = { handler: fn, name: 'test' } as Record<string, unknown>
+    expect(omitDeep(obj, ['name'])).toEqual({ handler: fn })
+  })
+
+  it('should handle object with array values at dot path', () => {
+    const obj = { tags: ['a', 'b'], name: 'test' }
+    expect(omitDeep(obj, ['tags'])).toEqual({ name: 'test' })
+  })
+
+  it('should unset non-empty RegExp at dot path', () => {
+    const obj = { config: { pattern: /test/i } }
+    expect(omitDeep(obj, ['config.pattern'])).toEqual({ config: {} })
+  })
+
+  it('should unset Error with message at dot path', () => {
+    const obj = { config: { err: new Error('oops') } }
+    expect(omitDeep(obj, ['config.err'])).toEqual({ config: {} })
+  })
+
+  it('should unset non-empty Map at dot path', () => {
+    const obj = { config: { data: new Map([['a', 1]]) } } as Record<string, unknown>
+    expect(omitDeep(obj, ['config.data'])).toEqual({ config: {} })
+  })
+
+  it('should not unset empty Map at dot path (hasValue is false)', () => {
+    const obj = { config: { data: new Map() } } as Record<string, unknown>
+    const result = omitDeep(obj, ['config.data'])
+    expect(result.config).toHaveProperty('data')
+  })
+
+  it('should unset non-empty Set at dot path', () => {
+    const obj = { config: { data: new Set([1]) } } as Record<string, unknown>
+    expect(omitDeep(obj, ['config.data'])).toEqual({ config: {} })
+  })
+
+  it('should not unset empty Set at dot path (hasValue is false)', () => {
+    const obj = { config: { data: new Set() } } as Record<string, unknown>
+    const result = omitDeep(obj, ['config.data'])
+    expect(result.config).toHaveProperty('data')
+  })
+
+  it('should handle null value at dot-notation intermediate', () => {
+    const obj = { a: null } as Record<string, unknown>
+    expect(omitDeep(obj, ['a.b'])).toEqual({ a: null })
+  })
+
+  it('should handle mixed arrays with primitives and objects', () => {
+    const arr = [1, 'two', { a: 1, b: 2 }, null]
+    expect(omitDeep(arr, ['a'])).toEqual([1, 'two', { b: 2 }, null])
+  })
+
+  it('should unset non-empty array at dot path', () => {
+    const obj = { config: { items: [1, 2] } }
+    expect(omitDeep(obj, ['config.items'])).toEqual({ config: {} })
+  })
+
+  it('should not unset empty array at dot path (hasValue is false)', () => {
+    const obj = { config: { items: [] } }
+    expect(omitDeep(obj, ['config.items'])).toEqual({ config: { items: [] } })
+  })
+})