ts-patch-mongoose 3.1.2 → 4.0.0

package/dist/index.mjs

@@ -1,7 +1,5 @@
 import mongoose, { Schema, model } from 'mongoose';
-import jsonpatch from 'fast-json-patch';
 import EventEmitter from 'node:events';
-import { assign } from 'power-assign';
 
 const HistorySchema = new Schema(
   {
@@ -248,6 +246,94 @@ class PatchEventEmitter extends EventEmitter {
 }
 const em = new PatchEventEmitter();
 
+const escapeToken = (key) => {
+  if (!key.includes("/") && !key.includes("~")) return key;
+  return key.replaceAll("~", "~0").replaceAll("/", "~1");
+};
+const joinPath = (base, key) => `${base}/${escapeToken(key)}`;
+const cloneValue = (value) => {
+  if (value === void 0) return null;
+  if (value === null || typeof value !== "object") return value;
+  return JSON.parse(JSON.stringify(value));
+};
+const isContainer = (value) => {
+  return typeof value === "object" && value !== null;
+};
+const keysOf = (value) => {
+  if (Array.isArray(value)) {
+    const indices = [];
+    for (let i = 0; i < value.length; i++) indices.push(String(i));
+    return indices;
+  }
+  return Object.keys(value);
+};
+const normalizeTarget = (target) => {
+  if (!isContainer(target) || Array.isArray(target)) return target;
+  const withToJSON = target;
+  return typeof withToJSON.toJSON === "function" ? withToJSON.toJSON() : target;
+};
+const emitTest = (path, value, invertible, out) => {
+  if (invertible) out.push({ op: "test", path, value: cloneValue(value) });
+};
+const emitReplace = (path, source, target, invertible, out) => {
+  emitTest(path, source, invertible, out);
+  out.push({ op: "replace", path, value: cloneValue(target) });
+};
+const emitRemove = (path, source, invertible, out) => {
+  emitTest(path, source, invertible, out);
+  out.push({ op: "remove", path });
+};
+const shouldTreatAsRemoval = (sourceChild, targetChild, sourceIsArray) => {
+  return targetChild === void 0 && sourceChild !== void 0 && !sourceIsArray;
+};
+const diffSourceKey = (scope, key) => {
+  const { source, target, targetKeySet, basePath, sourceIsArray, invertible, out } = scope;
+  const childPath = joinPath(basePath, key);
+  const sourceChild = source[key];
+  if (!targetKeySet.has(key)) {
+    emitRemove(childPath, sourceChild, invertible, out);
+    return;
+  }
+  const targetChild = target[key];
+  if (shouldTreatAsRemoval(sourceChild, targetChild, sourceIsArray)) {
+    emitRemove(childPath, sourceChild, invertible, out);
+    return;
+  }
+  diff(sourceChild, targetChild, childPath, invertible, out);
+};
+const diffAddedKeys = (target, sourceKeys, targetKeys, basePath, out) => {
+  const sourceKeySet = new Set(sourceKeys);
+  for (const key of targetKeys) {
+    if (sourceKeySet.has(key)) continue;
+    const targetChild = target[key];
+    if (targetChild === void 0) continue;
+    out.push({ op: "add", path: joinPath(basePath, key), value: cloneValue(targetChild) });
+  }
+};
+const diff = (source, target, basePath, invertible, out) => {
+  if (source === target) return;
+  const resolvedTarget = normalizeTarget(target);
+  const sourceIsArray = Array.isArray(source);
+  const targetIsArray = Array.isArray(resolvedTarget);
+  if (!isContainer(source) || !isContainer(resolvedTarget) || sourceIsArray !== targetIsArray) {
+    emitReplace(basePath, source, resolvedTarget, invertible, out);
+    return;
+  }
+  const sourceKeys = keysOf(source);
+  const targetKeys = keysOf(resolvedTarget);
+  const targetKeySet = new Set(targetKeys);
+  const scope = { source, target: resolvedTarget, targetKeySet, basePath, sourceIsArray, invertible, out };
+  for (const key of Array.from(sourceKeys).reverse()) {
+    diffSourceKey(scope, key);
+  }
+  diffAddedKeys(resolvedTarget, sourceKeys, targetKeys, basePath, out);
+};
+const compare = (source, target, invertible = false) => {
+  const out = [];
+  diff(source, target, "", invertible, out);
+  return out;
+};
+
 const isPlainObject = (val) => {
   if (Object.prototype.toString.call(val) !== "[object Object]") return false;
   const prot = Object.getPrototypeOf(val);
@@ -378,7 +464,7 @@ const updatePatch = async (opts, context, current, original) => {
   const currentObject = getJsonOmit(opts, current);
   const originalObject = getJsonOmit(opts, original);
   if (isEmpty(originalObject) || isEmpty(currentObject)) return;
-  const patch = jsonpatch.compare(originalObject, currentObject, true);
+  const patch = compare(originalObject, currentObject, true);
   if (isEmpty(patch)) return;
   emitEvent(context, opts.eventUpdated, { oldDoc: original, doc: current, patch });
   if (history) {
@@ -467,6 +553,186 @@ const saveHooksInitialize = (schema, opts) => {
   });
 };
 
+const hasOwn = Object.prototype.hasOwnProperty;
+const parseSegment = (segment) => {
+  const asNumber2 = Number(segment);
+  return Number.isInteger(asNumber2) && String(asNumber2) === segment ? asNumber2 : segment;
+};
+const parsePath = (path) => {
+  const [first, ...rest] = path.split(".").map(parseSegment);
+  let leaf = first ?? path;
+  const crumbs = [];
+  for (const key of rest) {
+    crumbs.push({ key: leaf, nextNumeric: typeof key === "number" });
+    leaf = key;
+  }
+  return { leaf, crumbs };
+};
+const deepEqualJson = (a, b) => {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return a === b;
+  }
+};
+const ensureContainer = (parent, key, hintNumeric) => {
+  const existing = parent[key];
+  if (existing !== null && typeof existing === "object") {
+    return existing;
+  }
+  const created = hintNumeric ? [] : {};
+  parent[key] = created;
+  return created;
+};
+const setAtPath = (doc, path, value) => {
+  const { leaf, crumbs } = parsePath(path);
+  let cursor = doc;
+  for (const crumb of crumbs) {
+    cursor = ensureContainer(cursor, crumb.key, crumb.nextNumeric);
+  }
+  cursor[leaf] = value;
+};
+const getAtPath = (doc, path) => {
+  const { leaf, crumbs } = parsePath(path);
+  let cursor = doc;
+  for (const crumb of crumbs) {
+    const next = cursor[crumb.key];
+    if (next === null || typeof next !== "object") return void 0;
+    cursor = next;
+  }
+  return { container: cursor, leaf, exists: hasOwn.call(cursor, leaf) };
+};
+const unsetAtPath = (doc, path) => {
+  const located = getAtPath(doc, path);
+  if (!located) return;
+  if (Array.isArray(located.container)) {
+    located.container[located.leaf] = void 0;
+  } else {
+    delete located.container[located.leaf];
+  }
+};
+const asNumber = (value) => typeof value === "number" ? value : 0;
+const toArray = (value) => Array.isArray(value) ? value : void 0;
+const shouldReplaceForMin = (current, candidate) => {
+  if (candidate === void 0) return false;
+  if (current === void 0) return true;
+  return candidate < current;
+};
+const shouldReplaceForMax = (current, candidate) => {
+  if (candidate === void 0) return false;
+  if (current === void 0) return true;
+  return candidate > current;
+};
+const operators = {
+  $set: (doc, path, value) => setAtPath(doc, path, value),
+  $unset: (doc, path) => unsetAtPath(doc, path),
+  $inc: (doc, path, delta) => {
+    const located = getAtPath(doc, path);
+    const current = located?.exists ? asNumber(located.container[located.leaf]) : 0;
+    setAtPath(doc, path, current + asNumber(delta));
+  },
+  $mul: (doc, path, factor) => {
+    const located = getAtPath(doc, path);
+    const current = located?.exists ? asNumber(located.container[located.leaf]) : 0;
+    setAtPath(doc, path, current * asNumber(factor));
+  },
+  $min: (doc, path, candidate) => {
+    const located = getAtPath(doc, path);
+    if (!located?.exists) {
+      setAtPath(doc, path, candidate);
+      return;
+    }
+    if (shouldReplaceForMin(located.container[located.leaf], candidate)) {
+      setAtPath(doc, path, candidate);
+    }
+  },
+  $max: (doc, path, candidate) => {
+    const located = getAtPath(doc, path);
+    if (!located?.exists) {
+      setAtPath(doc, path, candidate);
+      return;
+    }
+    if (shouldReplaceForMax(located.container[located.leaf], candidate)) {
+      setAtPath(doc, path, candidate);
+    }
+  },
+  $rename: (doc, path, newPath) => {
+    if (typeof newPath !== "string") return;
+    const located = getAtPath(doc, path);
+    if (!located?.exists) return;
+    const value = located.container[located.leaf];
+    unsetAtPath(doc, path);
+    setAtPath(doc, newPath, value);
+  },
+  $currentDate: (doc, path, spec) => {
+    const wantTimestamp = typeof spec === "object" && spec !== null && spec.$type === "timestamp";
+    setAtPath(doc, path, wantTimestamp ? Date.now() : /* @__PURE__ */ new Date());
+  },
+  $push: (doc, path, pushSpec) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) ?? [] : [];
+    const next = [...existing];
+    if (typeof pushSpec === "object" && pushSpec !== null && "$each" in pushSpec && Array.isArray(pushSpec.$each)) {
+      next.push(...pushSpec.$each);
+    } else {
+      next.push(pushSpec);
+    }
+    setAtPath(doc, path, next);
+  },
+  $addToSet: (doc, path, item) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) ?? [] : [];
+    const next = [...existing];
+    const rawItems = typeof item === "object" && item !== null && "$each" in item ? item.$each : item;
+    const toAdd = Array.isArray(rawItems) ? rawItems : [rawItems];
+    for (const candidate of toAdd) {
+      if (!next.some((existingEntry) => deepEqualJson(existingEntry, candidate))) {
+        next.push(candidate);
+      }
+    }
+    setAtPath(doc, path, next);
+  },
+  $pull: (doc, path, matcher) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) : void 0;
+    if (!existing) return;
+    const filtered = existing.filter((entry) => !deepEqualJson(entry, matcher));
+    setAtPath(doc, path, filtered);
+  },
+  $pullAll: (doc, path, values) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) : void 0;
+    if (!existing || !Array.isArray(values)) return;
+    const filtered = existing.filter((entry) => !values.some((target) => deepEqualJson(entry, target)));
+    setAtPath(doc, path, filtered);
+  },
+  $pop: (doc, path, direction) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) : void 0;
+    if (!existing || existing.length === 0) return;
+    const next = direction === -1 ? existing.slice(1) : existing.slice(0, -1);
+    setAtPath(doc, path, next);
+  }
+};
+const applyOperator = (doc, operator, fields) => {
+  const fn = operators[operator];
+  if (!fn || fields === null || typeof fields !== "object") return;
+  for (const [path, argument] of Object.entries(fields)) {
+    fn(doc, path, argument);
+  }
+};
+const applyUpdate = (doc, update) => {
+  const result = { ...doc };
+  for (const [key, value] of Object.entries(update)) {
+    if (key.startsWith("$")) {
+      applyOperator(result, key, value);
+    } else {
+      setAtPath(result, key, value);
+    }
+  }
+  return result;
+};
+
 const updateMethods = ["update", "updateOne", "replaceOne", "updateMany", "findOneAndUpdate", "findOneAndReplace", "findByIdAndUpdate"];
 const trackChangedFields = (fields, updated, changed) => {
   if (!fields) return;
@@ -475,30 +741,14 @@ const trackChangedFields = (fields, updated, changed) => {
     changed.set(root, updated[root]);
   }
 };
-const applyPullAll = (updated, fields, changed) => {
-  for (const [field, values] of Object.entries(fields)) {
-    const arr = updated[field];
-    if (Array.isArray(arr)) {
-      const filtered = arr.filter((item) => !values.some((v) => JSON.stringify(v) === JSON.stringify(item)));
-      updated[field] = filtered;
-      changed.set(field, filtered);
-    }
-  }
-};
 const assignUpdate = (document, update, commands) => {
-  let updated = assign(document.toObject(toObjectOptions), update);
+  let updated = applyUpdate(document.toObject(toObjectOptions), update);
   const changedByCommand = /* @__PURE__ */ new Map();
   for (const command of commands) {
     const [op = ""] = Object.keys(command);
     const fields = command[op];
-    try {
-      updated = assign(updated, command);
-      trackChangedFields(fields, updated, changedByCommand);
-    } catch {
-      if (op === "$pullAll" && fields) {
-        applyPullAll(updated, fields, changedByCommand);
-      }
-    }
+    updated = applyUpdate(updated, command);
+    trackChangedFields(fields, updated, changedByCommand);
   }
   const doc = document.set(updated).toObject(toObjectOptions);
   for (const [field, value] of changedByCommand) {
@@ -553,7 +803,9 @@ const updateHooksInitialize = (schema, opts) => {
     const updateQuery = this.getUpdate();
     const { update, commands } = splitUpdateAndCommands(updateQuery);
     const filter = this.getFilter();
-    const candidates = [update, assignUpdate(model.hydrate({}), update, commands), filter];
+    const simulated = assignUpdate(model.hydrate({}), update, commands);
+    const simulatedFilter = Object.fromEntries(Object.entries(simulated).filter(([, v]) => v !== void 0));
+    const candidates = [update, simulatedFilter, filter];
     let current = null;
     for (const query of candidates) {
       if (current || isEmpty(query)) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-patch-mongoose",
-  "version": "3.1.2",
+  "version": "4.0.0",
   "description": "Patch history & events for mongoose models",
   "author": "ilovepixelart",
   "license": "MIT",
@@ -12,9 +12,6 @@
     "url": "https://github.com/ilovepixelart/ts-patch-mongoose/issues"
   },
   "homepage": "https://github.com/ilovepixelart/ts-patch-mongoose#readme",
-  "directories": {
-    "examples": "examples"
-  },
   "keywords": [
     "backend",
     "mongoose",
@@ -36,11 +33,10 @@
     "log"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "type": "module",
   "exports": {
@@ -56,8 +52,11 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
-    "prepare": "simple-git-hooks",
     "biome": "npx @biomejs/biome check",
     "biome:fix": "npx @biomejs/biome check --write .",
     "test": "vitest run --coverage",
@@ -67,14 +66,11 @@
     "build": "pkgroll --clean-dist",
     "release": "npm install && npm run biome && npm run type:check && npm run type:check:tests && npm run build && np --no-publish"
   },
-  "dependencies": {
-    "fast-json-patch": "3.1.1",
-    "power-assign": "0.2.10"
-  },
   "devDependencies": {
     "@biomejs/biome": "2.4.11",
     "@types/node": "25.6.0",
     "@vitest/coverage-v8": "4.1.4",
+    "fast-check": "4.6.0",
     "mongodb-memory-server": "11.0.1",
     "mongoose": "9.4.1",
     "np": "11.0.3",

package/src/em.ts

@@ -1,6 +0,0 @@
-import EventEmitter from 'node:events'
-
-class PatchEventEmitter extends EventEmitter {}
-const em = new PatchEventEmitter()
-
-export default em

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