ts-patch-mongoose 3.1.0 → 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(
   {
@@ -98,9 +96,10 @@ const ms = (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] ?? 0);
+  const [, numStr, unitStr] = match;
+  const n = Number.parseFloat(String(numStr));
+  const type = (unitStr ?? "ms").toLowerCase();
+  return n * UNITS[type];
 };
 
 const isArray = Array.isArray;
@@ -247,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);
@@ -377,13 +464,13 @@ 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) {
     let version = 0;
     const lastHistory = await HistoryModel.findOne({ collectionId: original._id }).sort("-version").exec();
-    if (lastHistory && lastHistory.version >= 0) {
+    if (lastHistory) {
       version = lastHistory.version + 1;
     }
     const [user, reason, metadata] = await getData(opts, current);
@@ -466,38 +553,202 @@ 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;
   for (const key of Object.keys(fields)) {
-    const root = key.split(".")[0];
+    const [root = key] = key.split(".");
     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)[0];
+    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) {
@@ -552,11 +803,14 @@ 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;
-      current = await model.findOne(query).sort({ _id: -1 }).lean().exec();
+      const found = await model.findOne(query).sort({ _id: -1 }).lean().exec();
+      current = found;
     }
     if (current) {
       this._context.createdDocs = [current];
@@ -588,13 +842,14 @@ const patchHistoryPlugin = (schema, opts) => {
     await createPatch(opts, context);
   });
   if (isMongooseLessThan8) {
-    schema.pre(remove, { document: true, query: false }, async function() {
+    const legacySchema = schema;
+    legacySchema.pre(remove, { document: true, query: false }, async function() {
       const original = this.toObject(toObjectOptions);
       if (opts.preDelete && !isEmpty(original)) {
         await opts.preDelete([original]);
       }
     });
-    schema.post(remove, { document: true, query: false }, async function() {
+    legacySchema.post(remove, { document: true, query: false }, async function() {
       const original = this.toObject(toObjectOptions);
       const model = this.constructor;
       const context = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-patch-mongoose",
-  "version": "3.1.0",
+  "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,15 +33,10 @@
     "log"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "files": [
-    "dist",
-    "src",
-    "tests",
-    "tsconfig.json",
-    "vite.config.mts",
-    "biome.json"
+    "dist"
   ],
   "type": "module",
   "exports": {
@@ -60,32 +52,33 @@
   "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",
     "test:open": "vitest run --coverage && open-cli coverage/lcov-report/index.html",
     "type:check": "tsc --noEmit",
+    "type:check:tests": "tsc --noEmit -p tests/tsconfig.json",
     "build": "pkgroll --clean-dist",
-    "release": "npm install && npm run biome && npm run type:check && npm run build && np --no-publish"
-  },
-  "dependencies": {
-    "fast-json-patch": "3.1.1",
-    "power-assign": "0.2.10"
+    "release": "npm install && npm run biome && npm run type:check && npm run type:check:tests && npm run build && np --no-publish"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.9",
-    "@types/node": "25.5.0",
-    "@vitest/coverage-v8": "4.1.2",
+    "@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.3.3",
-    "np": "11.0.2",
+    "mongoose": "9.4.1",
+    "np": "11.0.3",
     "open-cli": "9.0.0",
     "pkgroll": "2.27.0",
     "simple-git-hooks": "2.13.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.2"
+    "vitest": "4.1.4"
   },
   "peerDependencies": {
     "mongoose": ">=6.6.0 < 10"
@@ -99,6 +92,8 @@
   },
   "overrides": {
     "tmp": "0.2.5",
-    "file-type": "21.3.2"
+    "file-type": "21.3.2",
+    "lodash": "4.18.1",
+    "vite": "8.0.8"
   }
 }

package/biome.json

@@ -1,47 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.4.9/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
-    }
-  },
-  "javascript": {
-    "formatter": {
-      "trailingCommas": "all",
-      "quoteStyle": "single",
-      "semicolons": "asNeeded",
-      "lineWidth": 320
-    },
-    "globals": ["Atomics", "SharedArrayBuffer"]
-  },
-  "json": {
-    "formatter": {
-      "trailingCommas": "none"
-    }
-  }
-}

package/src/em.ts

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