ts-patch-mongoose 3.0.0 → 3.1.2

package/src/index.ts

@@ -36,9 +36,13 @@ export const patchHistoryPlugin = <T>(schema: Schema<T>, opts: PluginOptions<T>)
   // In Mongoose 7, doc.deleteOne() returned a promise that resolved to doc.
   // In Mongoose 8, doc.deleteOne() returns a query for easier chaining, as well as consistency with doc.updateOne().
   if (isMongooseLessThan8) {
-    // @ts-expect-error - Mongoose 7 and below
-    schema.pre(remove, { document: true, query: false }, async function () {
-      // @ts-expect-error - Mongoose 7 and below
+    type LegacySchema = {
+      pre(name: string, options: { document: boolean; query: boolean }, fn: (this: HydratedDocument<T>) => Promise<void>): void
+      post(name: string, options: { document: boolean; query: boolean }, fn: (this: HydratedDocument<T>) => Promise<void>): void
+    }
+    const legacySchema = schema as unknown as LegacySchema
+
+    legacySchema.pre(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
       const original = this.toObject(toObjectOptions) as HydratedDocument<T>
 
       if (opts.preDelete && !isEmpty(original)) {
@@ -46,8 +50,7 @@ export const patchHistoryPlugin = <T>(schema: Schema<T>, opts: PluginOptions<T>)
       }
     })
 
-    // @ts-expect-error - Mongoose 7 and below
-    schema.post(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
+    legacySchema.post(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
       const original = this.toObject(toObjectOptions) as HydratedDocument<T>
       const model = this.constructor as Model<T>
 

package/src/ms.ts

@@ -60,7 +60,8 @@ export const ms = (val: Duration): number => {
   const match = RE.exec(str)
   if (!match) return Number.NaN
 
-  const n = Number.parseFloat(match[1] ?? '')
-  const type = (match[2] ?? 'ms').toLowerCase()
-  return n * (UNITS[type as Unit] ?? 0)
+  const [, numStr, unitStr] = match
+  const n = Number.parseFloat(String(numStr))
+  const type = (unitStr ?? 'ms').toLowerCase() as Unit
+  return n * UNITS[type]
 }

package/src/omit-deep.ts

@@ -8,74 +8,33 @@ const isUnsafeKey = (key: string): boolean => {
   return key === '__proto__' || key === 'constructor' || key === 'prototype'
 }
 
-const getValue = (obj: Record<string, unknown>, path: string): unknown => {
-  const segs = path.split('.')
-  let current: unknown = obj
-  for (const seg of segs) {
-    if (current == null || typeof current !== 'object') return undefined
-    current = (current as Record<string, unknown>)[seg]
-  }
-  return current
-}
-
-const hasValue = (val: unknown): boolean => {
-  if (val == null) return false
-  if (typeof val === 'boolean' || typeof val === 'number' || typeof val === 'function') return true
-  if (typeof val === 'string') return val.length !== 0
-  if (Array.isArray(val)) return val.length !== 0
-  if (val instanceof RegExp) return val.source !== '(?:)' && val.source !== ''
-  if (val instanceof Error) return val.message !== ''
-  if (val instanceof Map || val instanceof Set) return val.size !== 0
-  if (typeof val === 'object') {
-    for (const key of Object.keys(val)) {
-      if (hasValue((val as Record<string, unknown>)[key])) return true
-    }
-    return false
-  }
-  return true
-}
-
-const has = (obj: unknown, path: string): boolean => {
-  if (obj != null && typeof obj === 'object' && typeof path === 'string') {
-    return hasValue(getValue(obj as Record<string, unknown>, path))
-  }
-  return false
-}
+const classifyKeys = (omitKeys: string[]): { topLevel: Set<string>; nested: Map<string, string[]> } => {
+  const topLevel = new Set<string>()
+  const nested = new Map<string, string[]>()
 
-const unset = (obj: Record<string, unknown>, prop: string): boolean => {
-  if (typeof obj !== 'object' || obj === null) return false
-
-  if (Object.hasOwn(obj, prop)) {
-    delete obj[prop]
-    return true
-  }
-
-  if (has(obj, prop)) {
-    const segs = prop.split('.')
-    let last = segs.pop()
-    while (segs.length && segs.at(-1)?.slice(-1) === '\\') {
-      last = `${(segs.pop() as string).slice(0, -1)}.${last}`
-    }
-    let target: unknown = obj
-    while (segs.length) {
-      const seg = segs.shift() as string
-      if (isUnsafeKey(seg)) return false
-      target = (target as Record<string, unknown>)[seg]
+  for (const key of omitKeys) {
+    const dotIdx = key.indexOf('.')
+    if (dotIdx === -1) {
+      topLevel.add(key)
+    } else {
+      const head = key.slice(0, dotIdx)
+      const tail = key.slice(dotIdx + 1)
+      if (!isUnsafeKey(head)) {
+        const existing = nested.get(head) ?? []
+        existing.push(tail)
+        nested.set(head, existing)
+      }
     }
-    return delete (target as Record<string, unknown>)[last ?? '']
   }
 
-  return true
+  return { topLevel, nested }
 }
 
 export const omitDeep = <T>(value: T, keys: string | string[]): T => {
   if (value === undefined) return {} as T
 
   if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      value[i] = omitDeep(value[i], keys)
-    }
-    return value
+    return value.map((item) => omitDeep(item, keys)) as T
   }
 
   if (!isPlainObject(value)) return value
@@ -83,13 +42,15 @@ export const omitDeep = <T>(value: T, keys: string | string[]): T => {
   const omitKeys = typeof keys === 'string' ? [keys] : keys
   if (!Array.isArray(omitKeys)) return value
 
-  for (const key of omitKeys) {
-    unset(value, key)
-  }
+  const { topLevel, nested } = classifyKeys(omitKeys)
+  const result = {} as Record<string, unknown>
 
   for (const key of Object.keys(value)) {
-    ;(value as Record<string, unknown>)[key] = omitDeep((value as Record<string, unknown>)[key], omitKeys)
+    if (topLevel.has(key)) continue
+
+    const nestedKeys = nested.get(key)
+    result[key] = omitDeep((value as Record<string, unknown>)[key], nestedKeys ?? omitKeys)
   }
 
-  return value
+  return result as T
 }

package/src/patch.ts

@@ -11,51 +11,39 @@ const isPatchHistoryEnabled = <T>(opts: PluginOptions<T>, context: PatchContext<
   return !opts.patchHistoryDisabled && !context.ignorePatchHistory
 }
 
-export const getJsonOmit = <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Partial<T> => {
-  // NOSONAR — structuredClone cannot handle mongoose documents (they contain non-cloneable methods)
-  const object = JSON.parse(JSON.stringify(doc)) as Partial<T>
+const applyOmit = <T>(object: Partial<T>, opts: PluginOptions<T>): Partial<T> => {
+  return opts.omit ? omit(object, opts.omit) : object
+}
 
-  if (opts.omit) {
-    return omit(object, opts.omit)
-  }
+const replacer = (_key: string, value: unknown): unknown => (typeof value === 'bigint' ? value.toString() : value)
 
-  return object
+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> => {
-  if (opts.omit) {
-    return omit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit)
-  }
-
-  return doc
+  return applyOmit(isFunction(doc?.toObject) ? (doc.toObject() as Partial<T>) : doc, opts)
 }
 
-export const getUser = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<User | undefined> => {
-  if (isFunction(opts.getUser)) {
-    return await opts.getUser(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 const getReason = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<string | undefined> => {
-  if (isFunction(opts.getReason)) {
-    return await opts.getReason(doc)
-  }
-  return undefined
-}
+export const getUser = async <T>(opts: PluginOptions<T>, doc?: HydratedDocument<T>): Promise<User | undefined> => getOptionalField(opts.getUser, doc)
 
-export const getMetadata = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T>): Promise<Metadata | undefined> => {
-  if (isFunction(opts.getMetadata)) {
-    return await opts.getMetadata(doc)
-  }
-  return 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 const getData = async <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)]
   })
@@ -63,7 +51,11 @@ export const getData = async <T>(opts: PluginOptions<T>, doc: HydratedDocument<T
 
 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
+    }
   }
 }
 
@@ -80,7 +72,8 @@ export const bulkPatch = async <T>(opts: PluginOptions<T>, context: PatchContext
     const bulk = []
 
     for (const doc of batch) {
-      emitEvent(context, event, { [key]: doc })
+      const omitted = getObjectOmit(opts, doc)
+      emitEvent(context, event, { [key]: omitted })
 
       if (history) {
         const [user, reason, metadata] = await getData(opts, doc)
@@ -91,7 +84,7 @@ export const bulkPatch = async <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 }),
@@ -103,8 +96,9 @@ export const bulkPatch = async <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)
       })
     }
   }
@@ -133,11 +127,12 @@ export const updatePatch = async <T>(opts: PluginOptions<T>, context: PatchConte
       .sort('-version')
       .exec()
 
-    if (lastHistory && lastHistory.version >= 0) {
+    if (lastHistory) {
       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,
@@ -148,6 +143,8 @@ export const updatePatch = async <T>(opts: PluginOptions<T>, context: PatchConte
       ...(user !== undefined && { user }),
       ...(reason !== undefined && { reason }),
       ...(metadata !== undefined && { metadata }),
+    }).catch((error: MongooseError) => {
+      onError(error)
     })
   }
 }

package/src/types.ts

@@ -12,6 +12,8 @@ export interface History {
   reason?: string
   metadata?: object
   patch?: Operation[]
+  createdAt?: Date
+  updatedAt?: Date
 }
 
 export interface PatchEvent<T> {
@@ -49,4 +51,5 @@ export interface PluginOptions<T> {
   omit?: string[]
   patchHistoryDisabled?: boolean
   preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>
+  onError?: (error: Error) => void
 }

package/biome.json

@@ -1,50 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.4.7/schema.json",
-  "vcs": { "enabled": false, "clientKind": "git", "useIgnoreFile": false },
-  "files": {
-    "ignoreUnknown": false,
-    "includes": ["src/**/*.ts", "tests/**/*.ts"]
-  },
-  "formatter": { "enabled": true, "indentStyle": "space", "indentWidth": 2 },
-  "assist": {
-    "actions": {
-      "source": {
-        "organizeImports": {
-          "level": "on",
-          "options": {
-            "groups": [
-              "vitest",
-              ":BLANK_LINE:",
-              ":NODE:",
-              { "type": false },
-              ":BLANK_LINE:"
-            ]
-          }
-        }
-      }
-    }
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "correctness": {
-        "noUnusedVariables": "off"
-      }
-    }
-  },
-  "javascript": {
-    "formatter": {
-      "trailingCommas": "all",
-      "quoteStyle": "single",
-      "semicolons": "asNeeded",
-      "lineWidth": 320
-    },
-    "globals": ["Atomics", "SharedArrayBuffer"]
-  },
-  "json": {
-    "formatter": {
-      "trailingCommas": "none"
-    }
-  }
-}

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,54 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { patchEventEmitter } from '../src/index'
-import { emitEvent } from '../src/patch'
-
-describe('em', () => {
-  it('should subscribe and count', async () => {
-    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', async () => {
-    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).toHaveBeenCalledTimes(1)
-
-    patchEventEmitter.off('test', fn)
-  })
-
-  it('emitEvent ignore', async () => {
-    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)
-
-    patchEventEmitter.off('test', fn)
-  })
-})