ts-patch-mongoose 3.1.0 → 4.0.0

package/src/helpers.ts

@@ -1,174 +0,0 @@
-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)
-}
-
-export const toObjectOptions: ToObjectOptions = {
-  depopulate: true,
-  virtuals: false,
-}
-
-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)
-
-    if (!ttl && existingIndex) {
-      await HistoryModel.collection.dropIndex(name)
-      return
-    }
-
-    const milliseconds = ms(ttl)
-
-    if (milliseconds < 1000 && existingIndex) {
-      await HistoryModel.collection.dropIndex(name)
-      return
-    }
-
-    const expireAfterSeconds = milliseconds / 1000
-
-    if (existingIndex && existingIndex.expireAfterSeconds === expireAfterSeconds) {
-      return
-    }
-
-    if (existingIndex) {
-      await HistoryModel.collection.dropIndex(name)
-    }
-
-    await HistoryModel.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds, name })
-  } catch (err) {
-    const handler = onError ?? console.error
-    handler(err as Error)
-  }
-}

package/src/hooks/delete-hooks.ts

@@ -1,49 +0,0 @@
-import { cloneDeep, isArray, isEmpty, isHookIgnored } from '../helpers'
-import { deletePatch } from '../patch'
-
-import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema } from 'mongoose'
-import type { HookContext, PluginOptions } from '../types'
-
-const deleteMethods = ['remove', 'findOneAndDelete', 'findOneAndRemove', 'findByIdAndDelete', 'findByIdAndRemove', 'deleteOne', 'deleteMany']
-
-export const deleteHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
-  schema.pre(deleteMethods 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()
-
-    this._context = {
-      op: this.op,
-      modelName: opts.modelName ?? model.modelName,
-      collectionName: opts.collectionName ?? model.collection.collectionName,
-      ignoreEvent: options.ignoreEvent as boolean,
-      ignorePatchHistory: options.ignorePatchHistory as boolean,
-    }
-
-    if (['remove', 'deleteMany'].includes(this._context.op) && !options.single) {
-      const docs = await model.find<T>(filter).lean().exec()
-      if (!isEmpty(docs)) {
-        this._context.deletedDocs = docs as HydratedDocument<T>[]
-      }
-    } else {
-      const doc = await model.findOne<T>(filter).lean().exec()
-      if (!isEmpty(doc)) {
-        this._context.deletedDocs = [doc] as HydratedDocument<T>[]
-      }
-    }
-
-    if (opts.preDelete && isArray(this._context.deletedDocs) && !isEmpty(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/save-hooks.ts

@@ -1,30 +0,0 @@
-import { toObjectOptions } from '../helpers'
-import { createPatch, updatePatch } from '../patch'
-
-import type { HydratedDocument, Model, Schema } from 'mongoose'
-import type { PatchContext, PluginOptions } from '../types'
-
-export const saveHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
-  schema.pre('save', async function () {
-    if (this.constructor.name !== 'model') return
-
-    const current = this.toObject(toObjectOptions) as HydratedDocument<T>
-    const model = this.constructor as Model<T>
-
-    const context: PatchContext<T> = {
-      op: this.isNew ? 'create' : 'update',
-      modelName: opts.modelName ?? model.modelName,
-      collectionName: opts.collectionName ?? model.collection.collectionName,
-      createdDocs: [current],
-    }
-
-    if (this.isNew) {
-      await createPatch(opts, context)
-    } else {
-      const original = await model.findById(current._id).lean().exec()
-      if (original) {
-        await updatePatch(opts, context, current, original as HydratedDocument<T>)
-      }
-    }
-  })
-}

package/src/hooks/update-hooks.ts

@@ -1,125 +0,0 @@
-import { assign } from 'power-assign'
-import { cloneDeep, isArray, isEmpty, isHookIgnored, isObjectLike, toObjectOptions } from '../helpers'
-import { createPatch, updatePatch } from '../patch'
-
-import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema, UpdateQuery, UpdateWithAggregationPipeline } from 'mongoose'
-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) 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 {
-      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
-}
-
-export const splitUpdateAndCommands = <T>(updateQuery: UpdateWithAggregationPipeline | UpdateQuery<T> | null): { update: UpdateQuery<T>; commands: Record<string, unknown>[] } => {
-  let update: UpdateQuery<T> = {}
-  const commands: Record<string, unknown>[] = []
-
-  if (!isEmpty(updateQuery) && !isArray(updateQuery) && isObjectLike(updateQuery)) {
-    update = cloneDeep(updateQuery)
-    const keysWithDollarSign = Object.keys(update).filter((key) => key.startsWith('$'))
-    if (!isEmpty(keysWithDollarSign)) {
-      for (const key of keysWithDollarSign) {
-        commands.push({ [key]: update[key] as unknown })
-        delete update[key]
-      }
-    }
-  }
-
-  return { update, commands }
-}
-
-export const updateHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
-  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()
-
-    this._context = {
-      op: this.op,
-      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,
-    }
-
-    const updateQuery = this.getUpdate()
-    const { update, commands } = splitUpdateAndCommands(updateQuery)
-
-    const cursor = model.find(filter).cursor()
-    await cursor.eachAsync(async (doc: HydratedDocument<T>) => {
-      const origDoc = doc.toObject(toObjectOptions) as HydratedDocument<T>
-      await updatePatch(opts, this._context, assignUpdate(doc, update, commands), origDoc)
-    })
-  })
-
-  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
-
-    const model = this.model as Model<T>
-    const updateQuery = this.getUpdate()
-    const { update, commands } = splitUpdateAndCommands(updateQuery)
-
-    const filter = this.getFilter()
-    const candidates = [update, assignUpdate(model.hydrate({}), update, commands), filter]
-
-    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) {
-      this._context.createdDocs = [current] as HydratedDocument<T>[]
-
-      await createPatch(opts, this._context)
-    }
-  })
-}

package/src/index.ts

@@ -1,65 +0,0 @@
-import { isEmpty, toObjectOptions } from './helpers'
-import { deleteHooksInitialize } from './hooks/delete-hooks'
-import { saveHooksInitialize } from './hooks/save-hooks'
-import { updateHooksInitialize } from './hooks/update-hooks'
-import { createPatch, deletePatch } from './patch'
-import { isMongooseLessThan7, isMongooseLessThan8 } from './version'
-
-import type { HydratedDocument, Model, Schema } from 'mongoose'
-import type { PatchContext, PluginOptions } from './types'
-
-const remove = isMongooseLessThan7 ? 'remove' : 'deleteOne'
-
-export { default as patchEventEmitter } from './em'
-export { setPatchHistoryTTL } from './helpers'
-export * from './types'
-
-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)
-
-  schema.post('insertMany', async function (docs) {
-    const context = {
-      op: 'create',
-      modelName: opts.modelName ?? this.modelName,
-      collectionName: opts.collectionName ?? this.collection.collectionName,
-      createdDocs: docs as unknown as HydratedDocument<T>[],
-    }
-
-    await createPatch(opts, context)
-  })
-
-  /* v8 ignore start */
-  // 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
-      const original = this.toObject(toObjectOptions) as HydratedDocument<T>
-
-      if (opts.preDelete && !isEmpty(original)) {
-        await opts.preDelete([original])
-      }
-    })
-
-    // @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>
-      const model = this.constructor as Model<T>
-
-      const context: PatchContext<T> = {
-        op: 'delete',
-        modelName: opts.modelName ?? model.modelName,
-        collectionName: opts.collectionName ?? model.collection.collectionName,
-        deletedDocs: [original],
-      }
-
-      await deletePatch(opts, context)
-    })
-  }
-  /* v8 ignore end */
-}

package/src/model.ts

@@ -1,50 +0,0 @@
-import { model, Schema } from 'mongoose'
-
-import type { History } from './types'
-
-export const HistorySchema = new Schema<History>(
-  {
-    op: {
-      type: String,
-      required: true,
-    },
-    modelName: {
-      type: String,
-      required: true,
-    },
-    collectionName: {
-      type: String,
-      required: true,
-    },
-    collectionId: {
-      type: Schema.Types.ObjectId,
-      required: true,
-    },
-    doc: {
-      type: Object,
-    },
-    patch: {
-      type: Array,
-    },
-    user: {
-      type: Object,
-    },
-    reason: {
-      type: String,
-    },
-    metadata: {
-      type: Object,
-    },
-    version: {
-      type: Number,
-      min: 0,
-      default: 0,
-    },
-  },
-  { timestamps: true },
-)
-
-HistorySchema.index({ collectionId: 1, version: -1 })
-HistorySchema.index({ op: 1, modelName: 1, collectionName: 1, collectionId: 1, reason: 1, version: 1 })
-
-export const HistoryModel = model<History>('History', HistorySchema, 'history')

package/src/modules/power-assign.d.ts

@@ -1,3 +0,0 @@
-declare module 'power-assign' {
-  export function assign<T, U>(object1: T, object2: U): T & U
-}

package/src/ms.ts

@@ -1,66 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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
-}