ts-patch-mongoose 2.9.6 → 3.1.0

package/src/patch.ts

@@ -1,88 +1,79 @@
 import jsonpatch from 'fast-json-patch'
-// Using CJS lodash with .js extensions for ESM compatibility
-import chunk from 'lodash/chunk.js'
-import isEmpty from 'lodash/isEmpty.js'
-import isFunction from 'lodash/isFunction.js'
-import omit from 'omit-deep'
 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'
 
-function isPatchHistoryEnabled<T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean {
+const isPatchHistoryEnabled = <T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean => {
   return !opts.patchHistoryDisabled && !context.ignorePatchHistory
 }
 
-export function getJsonOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> {
-  const object = JSON.parse(JSON.stringify(doc)) as Partial<T>
-
-  if (opts.omit) {
-    return omit(object, opts.omit)
-  }
-
-  return object
+const applyOmit = <T>(object: Partial<T>, opts: PluginOptions<T>): Partial<T> => {
+  return opts.omit ? omit(object, opts.omit) : object
 }
 
-export function getObjectOmit<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> {
-  if (opts.omit) {
-    return omit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit)
-  }
+const replacer = (_key: string, value: unknown): unknown => (typeof value === 'bigint' ? value.toString() : value)
 
-  return doc
+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 async function getUser<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<User | undefined> {
-  if (isFunction(opts.getUser)) {
-    return await opts.getUser(doc)
-  }
-  return undefined
+export const getObjectOmit = <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> => {
+  return applyOmit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts)
 }
 
-export async function getReason<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<string | undefined> {
-  if (isFunction(opts.getReason)) {
-    return await opts.getReason(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 async function getMetadata<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<Metadata | undefined> {
-  if (isFunction(opts.getMetadata)) {
-    return await opts.getMetadata(doc)
-  }
-  return undefined
-}
+export const getUser = async <T>(opts: PluginOptions<T>, doc?: HydratedDocument<T>): Promise<User | undefined> => getOptionalField(opts.getUser, doc)
 
-export function getValue<T>(item: PromiseSettledResult<T>): T | 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
 }
 
-export async function getData<T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<[User | undefined, string | undefined, Metadata | 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 function emitEvent<T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void {
+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
+    }
   }
 }
 
-export async function bulkPatch<T>(opts: PluginOptions<T>, context: PatchContext<T>, eventKey: 'eventCreated' | 'eventDeleted', docsKey: 'createdDocs' | 'deletedDocs'): Promise<void> {
+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) || (!event && !history)) return
+  if (isEmpty(docs) || !docs || (!event && !history)) return
 
   const chunks = chunk(docs, 1000)
-  for (const chunk of chunks) {
+  for (const batch of chunks) {
     const bulk = []
 
-    for (const doc of chunk) {
-      emitEvent(context, event, { [key]: doc })
+    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)
@@ -93,7 +84,7 @@ export async function bulkPatch<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 }),
@@ -105,18 +96,19 @@ export async function bulkPatch<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)
       })
     }
   }
 }
 
-export async function createPatch<T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> {
+export const createPatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
   await bulkPatch(opts, context, 'eventCreated', 'createdDocs')
 }
 
-export async function updatePatch<T>(opts: PluginOptions<T>, context: PatchContext<T>, current: HydratedDocument<T>, original: HydratedDocument<T>): Promise<void> {
+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)
@@ -140,6 +132,7 @@ export async function updatePatch<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,
@@ -150,10 +143,12 @@ export async function updatePatch<T>(opts: PluginOptions<T>, context: PatchConte
       ...(user !== undefined && { user }),
       ...(reason !== undefined && { reason }),
       ...(metadata !== undefined && { metadata }),
+    }).catch((error: MongooseError) => {
+      onError(error)
     })
   }
 }
 
-export async function deletePatch<T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> {
+export const deletePatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
   await bulkPatch(opts, context, 'eventDeleted', 'deletedDocs')
 }

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/src/version.ts

@@ -1,9 +1,10 @@
 import mongoose from 'mongoose'
-import { satisfies } from 'semver'
 
-export const isMongooseLessThan8 = satisfies(mongoose.version, '<8')
-export const isMongooseLessThan7 = satisfies(mongoose.version, '<7')
-export const isMongoose6 = satisfies(mongoose.version, '6')
+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) {

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)
 
@@ -27,13 +31,12 @@ describe('em', () => {
       collectionName: 'tests',
     }
 
+    // @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)
 
@@ -44,9 +47,24 @@ describe('em', () => {
       collectionName: 'tests',
     }
 
+    // @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

@@ -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,292 @@ 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)
+  })
+
+  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/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()
+  })
+})