ts-patch-mongoose 2.9.6 → 3.1.0

package/src/helpers.ts

@@ -1,8 +1,134 @@
-import ms from 'ms'
 import { HistoryModel } from './model'
+import { type Duration, ms } from './ms'
 
 import type { QueryOptions, ToObjectOptions } from 'mongoose'
 
+export const isArray = Array.isArray
+
+export const isEmpty = (value: unknown): boolean => {
+  if (value == null) return true
+  if (Array.isArray(value) || typeof value === 'string') return value.length === 0
+  if (value instanceof Map || value instanceof Set) return value.size === 0
+  if (typeof value === 'object') {
+    for (const key in value) {
+      if (Object.hasOwn(value, key)) return false
+    }
+    return true
+  }
+  return true
+}
+
+export const isFunction = (value: unknown): value is (...args: unknown[]) => unknown => {
+  return typeof value === 'function'
+}
+
+export const isObjectLike = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null
+}
+
+const cloneArrayBuffer = (arrayBuffer: ArrayBuffer): ArrayBuffer => {
+  const result = new ArrayBuffer(arrayBuffer.byteLength)
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer))
+  return result
+}
+
+const cloneImmutable = <T>(value: T): T | undefined => {
+  const tag = Object.prototype.toString.call(value)
+
+  switch (tag) {
+    case '[object Date]':
+      return new Date(+(value as unknown as Date)) as T
+    case '[object RegExp]': {
+      const re = value as unknown as RegExp
+      const cloned = new RegExp(re.source, re.flags)
+      cloned.lastIndex = re.lastIndex
+      return cloned as T
+    }
+    case '[object Error]': {
+      const err = value as unknown as Error
+      const cloned = new (err.constructor as ErrorConstructor)(err.message)
+      if (err.stack) cloned.stack = err.stack
+      return cloned as T
+    }
+    case '[object ArrayBuffer]':
+      return cloneArrayBuffer(value as unknown as ArrayBuffer) as T
+    case '[object DataView]': {
+      const dv = value as unknown as DataView
+      const buffer = cloneArrayBuffer(dv.buffer as ArrayBuffer)
+      return new DataView(buffer, dv.byteOffset, dv.byteLength) as T
+    }
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    const ta = value as unknown as { buffer: ArrayBuffer; byteOffset: number; length: number }
+    const buffer = cloneArrayBuffer(ta.buffer)
+    return new (value.constructor as new (buffer: ArrayBuffer, byteOffset: number, length: number) => T)(buffer, ta.byteOffset, ta.length)
+  }
+
+  return undefined
+}
+
+const cloneCollection = <T extends object>(value: T, seen: WeakMap<object, unknown>): T => {
+  if (value instanceof Map) {
+    const map = new Map()
+    seen.set(value, map)
+    for (const [k, v] of value) map.set(k, cloneDeep(v, seen))
+    return map as T
+  }
+
+  if (value instanceof Set) {
+    const set = new Set()
+    seen.set(value, set)
+    for (const v of value) set.add(cloneDeep(v, seen))
+    return set as T
+  }
+
+  if (Array.isArray(value)) {
+    const arr = new Array(value.length) as unknown[]
+    seen.set(value, arr)
+    for (let i = 0; i < value.length; i++) {
+      arr[i] = cloneDeep(value[i], seen)
+    }
+    return arr as T
+  }
+
+  const result = typeof value.constructor === 'function' ? (Object.create(Object.getPrototypeOf(value) as object) as T) : ({} as T)
+  seen.set(value, result)
+  for (const key of Object.keys(value)) {
+    ;(result as Record<string, unknown>)[key] = cloneDeep((value as Record<string, unknown>)[key], seen)
+  }
+  return result
+}
+
+export const cloneDeep = <T>(value: T, seen = new WeakMap<object, unknown>()): T => {
+  if (value === null || typeof value !== 'object') return value
+  if (seen.has(value)) return seen.get(value) as T
+
+  const immutable = cloneImmutable(value)
+  if (immutable !== undefined) return immutable
+
+  const record = value as Record<string, unknown>
+
+  if (typeof record._bsontype === 'string' && typeof record.toHexString === 'function') {
+    return new (value.constructor as new (hex: string) => T)((record.toHexString as () => string)())
+  }
+
+  if (typeof record.toJSON === 'function') {
+    // NOSONAR — structuredClone cannot handle objects with non-cloneable methods (e.g. mongoose documents)
+    return JSON.parse(JSON.stringify(value)) as T
+  }
+
+  return cloneCollection(value, seen)
+}
+
+export const chunk = <T>(array: T[], size: number): T[][] => {
+  const result: T[][] = []
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size))
+  }
+  return result
+}
+
 export const isHookIgnored = <T>(options: QueryOptions<T>): boolean => {
   return options.ignoreHook === true || (options.ignoreEvent === true && options.ignorePatchHistory === true)
 }
@@ -12,21 +138,19 @@ export const toObjectOptions: ToObjectOptions = {
   virtuals: false,
 }
 
-export const setPatchHistoryTTL = async (ttl: number | ms.StringValue): Promise<void> => {
-  const name = 'createdAt_1_TTL' // To avoid collision with user defined index / manually created index
+export const setPatchHistoryTTL = async (ttl: Duration, onError?: (error: Error) => void): Promise<void> => {
+  const name = 'createdAt_1_TTL'
   try {
     const indexes = await HistoryModel.collection.indexes()
     const existingIndex = indexes?.find((index) => index.name === name)
 
-    // Drop the index if historyTTL is not set and index exists
     if (!ttl && existingIndex) {
       await HistoryModel.collection.dropIndex(name)
       return
     }
 
-    const milliseconds = typeof ttl === 'string' ? ms(ttl) : ttl
+    const milliseconds = ms(ttl)
 
-    // Drop the index if historyTTL is less than 1 second and index exists
     if (milliseconds < 1000 && existingIndex) {
       await HistoryModel.collection.dropIndex(name)
       return
@@ -35,18 +159,16 @@ export const setPatchHistoryTTL = async (ttl: number | ms.StringValue): Promise<
     const expireAfterSeconds = milliseconds / 1000
 
     if (existingIndex && existingIndex.expireAfterSeconds === expireAfterSeconds) {
-      // Index already exists with the correct TTL, no need to recreate
       return
     }
 
     if (existingIndex) {
-      // Drop the existing index if it exists and TTL is different
       await HistoryModel.collection.dropIndex(name)
     }
 
-    // Create a new index with the correct TTL if it doesn't exist or if the TTL is different
     await HistoryModel.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds, name })
   } catch (err) {
-    console.error("Couldn't create or update index for history collection", err)
+    const handler = onError ?? console.error
+    handler(err as Error)
   }
 }

package/src/hooks/delete-hooks.ts

@@ -1,7 +1,4 @@
-// Using CJS lodash with .js extensions for ESM compatibility
-import isArray from 'lodash/isArray.js'
-import isEmpty from 'lodash/isEmpty.js'
-import { isHookIgnored } from '../helpers'
+import { cloneDeep, isArray, isEmpty, isHookIgnored } from '../helpers'
 import { deletePatch } from '../patch'
 
 import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema } from 'mongoose'
@@ -19,8 +16,8 @@ export const deleteHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<
 
     this._context = {
       op: this.op,
-      modelName: opts.modelName ?? this.model.modelName,
-      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
       ignoreEvent: options.ignoreEvent as boolean,
       ignorePatchHistory: options.ignorePatchHistory as boolean,
     }
@@ -38,13 +35,14 @@ export const deleteHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<
     }
 
     if (opts.preDelete && isArray(this._context.deletedDocs) && !isEmpty(this._context.deletedDocs)) {
-      await opts.preDelete(this._context.deletedDocs)
+      await opts.preDelete(cloneDeep(this._context.deletedDocs))
     }
   })
 
   schema.post(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: HookContext<T>) {
     const options = this.getOptions()
     if (isHookIgnored(options)) return
+    if (!this._context) return
 
     await deletePatch(opts, this._context)
   })

package/src/hooks/update-hooks.ts

@@ -1,12 +1,5 @@
-// Using CJS lodash with .js extensions for ESM compatibility
-import cloneDeep from 'lodash/cloneDeep.js'
-import forEach from 'lodash/forEach.js'
-import isArray from 'lodash/isArray.js'
-import isEmpty from 'lodash/isEmpty.js'
-import isObjectLike from 'lodash/isObjectLike.js'
-import keys from 'lodash/keys.js'
 import { assign } from 'power-assign'
-import { isHookIgnored, toObjectOptions } from '../helpers'
+import { cloneDeep, isArray, isEmpty, isHookIgnored, isObjectLike, toObjectOptions } from '../helpers'
 import { createPatch, updatePatch } from '../patch'
 
 import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema, UpdateQuery, UpdateWithAggregationPipeline } from 'mongoose'
@@ -14,18 +7,46 @@ import type { HookContext, PluginOptions } from '../types'
 
 const updateMethods = ['update', 'updateOne', 'replaceOne', 'updateMany', 'findOneAndUpdate', 'findOneAndReplace', 'findByIdAndUpdate']
 
+const trackChangedFields = (fields: Record<string, unknown> | undefined, updated: Record<string, unknown>, changed: Map<string, unknown>): void => {
+  if (!fields) return
+  for (const key of Object.keys(fields)) {
+    const root = key.split('.')[0] as string
+    changed.set(root, updated[root])
+  }
+}
+
+const applyPullAll = (updated: Record<string, unknown>, fields: Record<string, unknown[]>, changed: Map<string, unknown>): void => {
+  for (const [field, values] of Object.entries(fields)) {
+    const arr = updated[field]
+    if (Array.isArray(arr)) {
+      const filtered = arr.filter((item: unknown) => !values.some((v) => JSON.stringify(v) === JSON.stringify(item)))
+      updated[field] = filtered
+      changed.set(field, filtered)
+    }
+  }
+}
+
 export const assignUpdate = <T>(document: HydratedDocument<T>, update: UpdateQuery<T>, commands: Record<string, unknown>[]): HydratedDocument<T> => {
-  let updated = assign(document.toObject(toObjectOptions), update)
-  // Try catch not working for of loop, keep it as is
-  forEach(commands, (command) => {
+  let updated = assign(document.toObject(toObjectOptions), update) as Record<string, unknown>
+  const changedByCommand = new Map<string, unknown>()
+
+  for (const command of commands) {
+    const op = Object.keys(command)[0] as string
+    const fields = command[op] as Record<string, unknown> | undefined
     try {
       updated = assign(updated, command)
+      trackChangedFields(fields, updated, changedByCommand)
     } catch {
-      // we catch assign keys that are not implemented
+      if (op === '$pullAll' && fields) {
+        applyPullAll(updated, fields as Record<string, unknown[]>, changedByCommand)
+      }
     }
-  })
+  }
 
   const doc = document.set(updated).toObject(toObjectOptions) as HydratedDocument<T> & { createdAt?: Date }
+  for (const [field, value] of changedByCommand) {
+    ;(doc as unknown as Record<string, unknown>)[field] = value
+  }
   if (update.createdAt) doc.createdAt = update.createdAt
   return doc
 }
@@ -36,12 +57,12 @@ export const splitUpdateAndCommands = <T>(updateQuery: UpdateWithAggregationPipe
 
   if (!isEmpty(updateQuery) && !isArray(updateQuery) && isObjectLike(updateQuery)) {
     update = cloneDeep(updateQuery)
-    const keysWithDollarSign = keys(update).filter((key) => key.startsWith('$'))
+    const keysWithDollarSign = Object.keys(update).filter((key) => key.startsWith('$'))
     if (!isEmpty(keysWithDollarSign)) {
-      forEach(keysWithDollarSign, (key) => {
+      for (const key of keysWithDollarSign) {
         commands.push({ [key]: update[key] as unknown })
         delete update[key]
-      })
+      }
     }
   }
 
@@ -49,19 +70,18 @@ export const splitUpdateAndCommands = <T>(updateQuery: UpdateWithAggregationPipe
 }
 
 export const updateHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
-  schema.pre(updateMethods as MongooseQueryMiddleware[], async function (this: HookContext<T>) {
+  schema.pre(updateMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: HookContext<T>) {
     const options = this.getOptions()
     if (isHookIgnored(options)) return
 
     const model = this.model as Model<T>
     const filter = this.getFilter()
-    const count = await this.model.countDocuments(filter).exec()
 
     this._context = {
       op: this.op,
-      modelName: opts.modelName ?? this.model.modelName,
-      collectionName: opts.collectionName ?? this.model.collection.collectionName,
-      isNew: Boolean(options.upsert) && count === 0,
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
+      isNew: Boolean(options.upsert) && (await model.countDocuments(filter).exec()) === 0,
       ignoreEvent: options.ignoreEvent as boolean,
       ignorePatchHistory: options.ignorePatchHistory as boolean,
     }
@@ -76,9 +96,10 @@ export const updateHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<
     })
   })
 
-  schema.post(updateMethods as MongooseQueryMiddleware[], async function (this: HookContext<T>) {
+  schema.post(updateMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: HookContext<T>) {
     const options = this.getOptions()
     if (isHookIgnored(options)) return
+    if (!this._context) return
 
     if (!this._context.isNew) return
 
@@ -86,20 +107,13 @@ export const updateHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<
     const updateQuery = this.getUpdate()
     const { update, commands } = splitUpdateAndCommands(updateQuery)
 
-    let current: HydratedDocument<T> | null = null
     const filter = this.getFilter()
-    const combined = assignUpdate(model.hydrate({}), update, commands)
-    if (!isEmpty(update) && !current) {
-      current = (await model.findOne(update).sort('desc').lean().exec()) as HydratedDocument<T>
-    }
-
-    if (!isEmpty(combined) && !current) {
-      current = (await model.findOne(combined).sort('desc').lean().exec()) as HydratedDocument<T>
-    }
+    const candidates = [update, assignUpdate(model.hydrate({}), update, commands), filter]
 
-    if (!isEmpty(filter) && !current) {
-      console.log('filter', filter)
-      current = (await model.findOne(filter).sort('desc').lean().exec()) as HydratedDocument<T>
+    let current: HydratedDocument<T> | null = null
+    for (const query of candidates) {
+      if (current || isEmpty(query)) continue
+      current = (await model.findOne(query).sort({ _id: -1 }).lean().exec()) as HydratedDocument<T>
     }
 
     if (current) {

package/src/index.ts

@@ -1,6 +1,4 @@
-// Using CJS lodash with .js extension for ESM compatibility
-import isEmpty from 'lodash/isEmpty.js'
-import { toObjectOptions } from './helpers'
+import { isEmpty, toObjectOptions } from './helpers'
 import { deleteHooksInitialize } from './hooks/delete-hooks'
 import { saveHooksInitialize } from './hooks/save-hooks'
 import { updateHooksInitialize } from './hooks/update-hooks'
@@ -12,34 +10,17 @@ import type { PatchContext, PluginOptions } from './types'
 
 const remove = isMongooseLessThan7 ? 'remove' : 'deleteOne'
 
-/**
- * @description Event emitter for patch operations.
- */
 export { default as patchEventEmitter } from './em'
 export { setPatchHistoryTTL } from './helpers'
 export * from './types'
 
-/**
- * @description Mongoose plugin to track and manage patch history for documents.
- * This plugin initializes hooks for save, update, and delete operations to create
- * and manage patches.
- *
- * @template T
- * @param {Schema<T>} schema - The Mongoose schema to apply the plugin to.
- * @param {PluginOptions<T>} opts - Options for configuring the plugin.
- * @returns {void}
- */
-export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: PluginOptions<T>): void {
-  // Initialize hooks
+export type { Duration } from './ms'
+
+export const patchHistoryPlugin = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
   saveHooksInitialize(schema, opts)
   updateHooksInitialize(schema, opts)
   deleteHooksInitialize(schema, opts)
 
-  /**
-   * @description Corner case for insertMany()
-   * @param {Array<HydratedDocument<T>>} docs - The documents being inserted.
-   * @returns {Promise<void>}
-   */
   schema.post('insertMany', async function (docs) {
     const context = {
       op: 'create',
@@ -55,10 +36,6 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: Pl
   // 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) {
-    /**
-     * @description Pre-delete hook for Mongoose 7 and below
-     * @returns {Promise<void>}
-     */
     // @ts-expect-error - Mongoose 7 and below
     schema.pre(remove, { document: true, query: false }, async function () {
       // @ts-expect-error - Mongoose 7 and below
@@ -69,11 +46,6 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: Pl
       }
     })
 
-    /**
-     * @description Post-delete hook for Mongoose 7 and below
-     * @param {HydratedDocument<T>} this - The document being deleted.
-     * @returns {Promise<void>}
-     */
     // @ts-expect-error - Mongoose 7 and below
     schema.post(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
       const original = this.toObject(toObjectOptions) as HydratedDocument<T>

package/src/ms.ts

@@ -0,0 +1,66 @@
+const s = 1000
+const m = s * 60
+const h = m * 60
+const d = h * 24
+const w = d * 7
+const y = d * 365.25
+const mo = y / 12
+
+export const UNITS = {
+  milliseconds: 1,
+  millisecond: 1,
+  msecs: 1,
+  msec: 1,
+  ms: 1,
+  seconds: s,
+  second: s,
+  secs: s,
+  sec: s,
+  s,
+  minutes: m,
+  minute: m,
+  mins: m,
+  min: m,
+  m,
+  hours: h,
+  hour: h,
+  hrs: h,
+  hr: h,
+  h,
+  days: d,
+  day: d,
+  d,
+  weeks: w,
+  week: w,
+  w,
+  months: mo,
+  month: mo,
+  mo,
+  years: y,
+  year: y,
+  yrs: y,
+  yr: y,
+  y,
+} as const satisfies Record<string, number>
+
+export type Unit = keyof typeof UNITS
+
+export type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`
+
+const unitPattern = Object.keys(UNITS)
+  .sort((a, b) => b.length - a.length)
+  .join('|')
+
+const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, 'i')
+
+export const ms = (val: Duration): number => {
+  const str = String(val)
+  if (str.length > 100) return Number.NaN
+
+  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)
+}

package/src/omit-deep.ts

@@ -0,0 +1,56 @@
+const isPlainObject = (val: unknown): val is Record<string, unknown> => {
+  if (Object.prototype.toString.call(val) !== '[object Object]') return false
+  const prot = Object.getPrototypeOf(val) as object | null
+  return prot === null || prot === Object.prototype
+}
+
+const isUnsafeKey = (key: string): boolean => {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype'
+}
+
+const classifyKeys = (omitKeys: string[]): { topLevel: Set<string>; nested: Map<string, string[]> } => {
+  const topLevel = new Set<string>()
+  const nested = new Map<string, string[]>()
+
+  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 { topLevel, nested }
+}
+
+export const omitDeep = <T>(value: T, keys: string | string[]): T => {
+  if (value === undefined) return {} as T
+
+  if (Array.isArray(value)) {
+    return value.map((item) => omitDeep(item, keys)) as T
+  }
+
+  if (!isPlainObject(value)) return value
+
+  const omitKeys = typeof keys === 'string' ? [keys] : keys
+  if (!Array.isArray(omitKeys)) return value
+
+  const { topLevel, nested } = classifyKeys(omitKeys)
+  const result = {} as Record<string, unknown>
+
+  for (const key of Object.keys(value)) {
+    if (topLevel.has(key)) continue
+
+    const nestedKeys = nested.get(key)
+    result[key] = omitDeep((value as Record<string, unknown>)[key], nestedKeys ?? omitKeys)
+  }
+
+  return result as T
+}