ts-patch-mongoose 2.9.6 → 3.0.0

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: [] } })
+  })
+})