ts-patch-mongoose 3.1.2 → 4.0.0

package/src/hooks/update-hooks.ts

@@ -1,130 +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] = key.split('.')
-    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)
-    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
-      const found = await model
-        .findOne(query as never)
-        .sort({ _id: -1 })
-        .lean()
-        .exec()
-      current = found as HydratedDocument<T>
-    }
-
-    if (current) {
-      this._context.createdDocs = [current] as HydratedDocument<T>[]
-
-      await createPatch(opts, this._context)
-    }
-  })
-}

package/src/index.ts

@@ -1,68 +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) {
-    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)) {
-        await opts.preDelete([original])
-      }
-    })
-
-    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>
-
-      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,67 +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 [, 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

@@ -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
-}

package/src/patch.ts

@@ -1,154 +0,0 @@
-import jsonpatch from 'fast-json-patch'
-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'
-
-const isPatchHistoryEnabled = <T>(opts: PluginOptions<T>, context: PatchContext<T>): boolean => {
-  return !opts.patchHistoryDisabled && !context.ignorePatchHistory
-}
-
-const applyOmit = <T>(object: Partial<T>, opts: PluginOptions<T>): Partial<T> => {
-  return opts.omit ? omit(object, opts.omit) : object
-}
-
-const replacer = (_key: string, value: unknown): unknown => (typeof value === 'bigint' ? value.toString() : value)
-
-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> => {
-  return applyOmit(isFunction(doc?.toObject) ? (doc.toObject() as Partial<T>) : doc, opts)
-}
-
-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 getUser = async <T>(opts: PluginOptions<T>, doc?: HydratedDocument<T>): Promise<User | undefined> => getOptionalField(opts.getUser, doc)
-
-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]> => {
-  return Promise.allSettled([getUser(opts, doc), getReason(opts, doc), getMetadata(opts, doc)]).then(([user, reason, metadata]) => {
-    return [getValue(user), getValue(reason), getValue(metadata)]
-  })
-}
-
-export const emitEvent = <T>(context: PatchContext<T>, event: string | undefined, data: PatchEvent<T>): void => {
-  if (event && !context.ignoreEvent) {
-    try {
-      em.emit(event, data)
-    } catch {
-      // Listener errors must not crash patch history recording
-    }
-  }
-}
-
-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) || !docs || (!event && !history)) return
-
-  const chunks = chunk(docs, 1000)
-  for (const batch of chunks) {
-    const bulk = []
-
-    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)
-        bulk.push({
-          insertOne: {
-            document: {
-              op: context.op,
-              modelName: context.modelName,
-              collectionName: context.collectionName,
-              collectionId: doc._id as Types.ObjectId,
-              doc: omitted,
-              version: 0,
-              ...(user !== undefined && { user }),
-              ...(reason !== undefined && { reason }),
-              ...(metadata !== undefined && { metadata }),
-            },
-          },
-        })
-      }
-    }
-
-    if (history && !isEmpty(bulk)) {
-      const onError = opts.onError ?? console.error
-      await HistoryModel.bulkWrite(bulk, { ordered: false }).catch((error: MongooseError) => {
-        onError(error)
-      })
-    }
-  }
-}
-
-export const createPatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
-  await bulkPatch(opts, context, 'eventCreated', 'createdDocs')
-}
-
-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)
-  const originalObject = getJsonOmit(opts, original)
-  if (isEmpty(originalObject) || isEmpty(currentObject)) return
-
-  const patch = jsonpatch.compare(originalObject, currentObject, true)
-  if (isEmpty(patch)) return
-
-  emitEvent(context, opts.eventUpdated, { oldDoc: original, doc: current, patch })
-
-  if (history) {
-    let version = 0
-
-    const lastHistory = await HistoryModel.findOne({ collectionId: original._id as Types.ObjectId })
-      .sort('-version')
-      .exec()
-
-    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,
-      collectionName: context.collectionName,
-      collectionId: original._id as Types.ObjectId,
-      patch,
-      version,
-      ...(user !== undefined && { user }),
-      ...(reason !== undefined && { reason }),
-      ...(metadata !== undefined && { metadata }),
-    }).catch((error: MongooseError) => {
-      onError(error)
-    })
-  }
-}
-
-export const deletePatch = async <T>(opts: PluginOptions<T>, context: PatchContext<T>): Promise<void> => {
-  await bulkPatch(opts, context, 'eventDeleted', 'deletedDocs')
-}

package/src/types.ts

@@ -1,55 +0,0 @@
-import type { Operation } from 'fast-json-patch'
-import type { HydratedDocument, Query, Types } from 'mongoose'
-
-export interface History {
-  op: string
-  modelName: string
-  collectionName: string
-  collectionId: Types.ObjectId
-  version: number
-  doc?: object
-  user?: object
-  reason?: string
-  metadata?: object
-  patch?: Operation[]
-  createdAt?: Date
-  updatedAt?: Date
-}
-
-export interface PatchEvent<T> {
-  oldDoc?: HydratedDocument<T>
-  doc?: HydratedDocument<T>
-  patch?: Operation[]
-}
-
-export interface PatchContext<T> {
-  op: string
-  modelName: string
-  collectionName: string
-  isNew?: boolean
-  createdDocs?: HydratedDocument<T>[]
-  deletedDocs?: HydratedDocument<T>[]
-  ignoreEvent?: boolean
-  ignorePatchHistory?: boolean
-}
-
-export type HookContext<T> = Query<T, T> & { op: string; _context: PatchContext<T> }
-
-export type User = Record<string, unknown>
-
-export type Metadata = Record<string, unknown>
-
-export interface PluginOptions<T> {
-  modelName?: string
-  collectionName?: string
-  eventUpdated?: string
-  eventCreated?: string
-  eventDeleted?: string
-  getUser?: (doc: HydratedDocument<T>) => Promise<User> | User
-  getReason?: (doc: HydratedDocument<T>) => Promise<string> | string
-  getMetadata?: (doc: HydratedDocument<T>) => Promise<Metadata> | Metadata
-  omit?: string[]
-  patchHistoryDisabled?: boolean
-  preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>
-  onError?: (error: Error) => void
-}

package/src/version.ts

@@ -1,13 +0,0 @@
-import mongoose from 'mongoose'
-
-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) {
-  mongoose.set('strictQuery', false)
-}
-/* v8 ignore end */