ts-patch-mongoose 2.9.6 → 3.0.0

package/dist/index.mjs

@@ -1,18 +1,7 @@
-import isEmpty from 'lodash/isEmpty.js';
-import ms from 'ms';
 import mongoose, { Schema, model } from 'mongoose';
-import isArray from 'lodash/isArray.js';
 import jsonpatch from 'fast-json-patch';
-import chunk from 'lodash/chunk.js';
-import isFunction from 'lodash/isFunction.js';
-import omit from 'omit-deep';
 import EventEmitter from 'node:events';
-import cloneDeep from 'lodash/cloneDeep.js';
-import forEach from 'lodash/forEach.js';
-import isObjectLike from 'lodash/isObjectLike.js';
-import keys from 'lodash/keys.js';
 import { assign } from 'power-assign';
-import { satisfies } from 'semver';
 
 const HistorySchema = new Schema(
   {
@@ -59,6 +48,156 @@ HistorySchema.index({ collectionId: 1, version: -1 });
 HistorySchema.index({ op: 1, modelName: 1, collectionName: 1, collectionId: 1, reason: 1, version: 1 });
 const HistoryModel = model("History", HistorySchema, "history");
 
+const s = 1e3;
+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;
+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
+};
+const unitPattern = Object.keys(UNITS).sort((a, b) => b.length - a.length).join("|");
+const RE = new RegExp(String.raw`^(-?(?:\d+)?\.?\d+)\s*(${unitPattern})?$`, "i");
+const ms = (val) => {
+  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] ?? 0);
+};
+
+const isArray = Array.isArray;
+const isEmpty = (value) => {
+  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;
+};
+const isFunction = (value) => {
+  return typeof value === "function";
+};
+const isObjectLike = (value) => {
+  return typeof value === "object" && value !== null;
+};
+const cloneArrayBuffer = (arrayBuffer) => {
+  const result = new ArrayBuffer(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+};
+const cloneImmutable = (value) => {
+  const tag = Object.prototype.toString.call(value);
+  switch (tag) {
+    case "[object Date]":
+      return /* @__PURE__ */ new Date(+value);
+    case "[object RegExp]": {
+      const re = value;
+      const cloned = new RegExp(re.source, re.flags);
+      cloned.lastIndex = re.lastIndex;
+      return cloned;
+    }
+    case "[object ArrayBuffer]":
+      return cloneArrayBuffer(value);
+    case "[object DataView]": {
+      const dv = value;
+      const buffer = cloneArrayBuffer(dv.buffer);
+      return new DataView(buffer, dv.byteOffset, dv.byteLength);
+    }
+  }
+  if (ArrayBuffer.isView(value)) {
+    const ta = value;
+    const buffer = cloneArrayBuffer(ta.buffer);
+    return new value.constructor(buffer, ta.byteOffset, ta.length);
+  }
+  return void 0;
+};
+const cloneCollection = (value, seen) => {
+  if (value instanceof Map) {
+    const map = /* @__PURE__ */ new Map();
+    seen.set(value, map);
+    for (const [k, v] of value) map.set(k, cloneDeep(v, seen));
+    return map;
+  }
+  if (value instanceof Set) {
+    const set = /* @__PURE__ */ new Set();
+    seen.set(value, set);
+    for (const v of value) set.add(cloneDeep(v, seen));
+    return set;
+  }
+  if (Array.isArray(value)) {
+    const arr = new Array(value.length);
+    seen.set(value, arr);
+    for (let i = 0; i < value.length; i++) {
+      arr[i] = cloneDeep(value[i], seen);
+    }
+    return arr;
+  }
+  const result = typeof value.constructor === "function" ? Object.create(Object.getPrototypeOf(value)) : {};
+  seen.set(value, result);
+  for (const key of Object.keys(value)) {
+    result[key] = cloneDeep(value[key], seen);
+  }
+  return result;
+};
+const cloneDeep = (value, seen = /* @__PURE__ */ new WeakMap()) => {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  const immutable = cloneImmutable(value);
+  if (immutable !== void 0) return immutable;
+  if ("toJSON" in value && typeof value.toJSON === "function") {
+    return JSON.parse(JSON.stringify(value));
+  }
+  return cloneCollection(value, seen);
+};
+const chunk = (array, size) => {
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+};
 const isHookIgnored = (options) => {
   return options.ignoreHook === true || options.ignoreEvent === true && options.ignorePatchHistory === true;
 };
@@ -75,7 +214,7 @@ const setPatchHistoryTTL = async (ttl) => {
       await HistoryModel.collection.dropIndex(name);
       return;
     }
-    const milliseconds = typeof ttl === "string" ? ms(ttl) : ttl;
+    const milliseconds = ms(ttl);
     if (milliseconds < 1e3 && existingIndex) {
       await HistoryModel.collection.dropIndex(name);
       return;
@@ -97,63 +236,144 @@ class PatchEventEmitter extends EventEmitter {
 }
 const em = new PatchEventEmitter();
 
-function isPatchHistoryEnabled(opts, context) {
+const isPlainObject = (val) => {
+  if (Object.prototype.toString.call(val) !== "[object Object]") return false;
+  const prot = Object.getPrototypeOf(val);
+  return prot === null || prot === Object.prototype;
+};
+const isUnsafeKey = (key) => {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+};
+const getValue$1 = (obj, path) => {
+  const segs = path.split(".");
+  let current = obj;
+  for (const seg of segs) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[seg];
+  }
+  return current;
+};
+const hasValue = (val) => {
+  if (val == null) return false;
+  if (typeof val === "boolean" || typeof val === "number" || typeof val === "function") return true;
+  if (typeof val === "string") return val.length !== 0;
+  if (Array.isArray(val)) return val.length !== 0;
+  if (val instanceof RegExp) return val.source !== "(?:)" && val.source !== "";
+  if (val instanceof Error) return val.message !== "";
+  if (val instanceof Map || val instanceof Set) return val.size !== 0;
+  if (typeof val === "object") {
+    for (const key of Object.keys(val)) {
+      if (hasValue(val[key])) return true;
+    }
+    return false;
+  }
+  return true;
+};
+const has = (obj, path) => {
+  if (obj != null && typeof obj === "object" && typeof path === "string") {
+    return hasValue(getValue$1(obj, path));
+  }
+  return false;
+};
+const unset = (obj, prop) => {
+  if (typeof obj !== "object" || obj === null) return false;
+  if (Object.hasOwn(obj, prop)) {
+    delete obj[prop];
+    return true;
+  }
+  if (has(obj, prop)) {
+    const segs = prop.split(".");
+    let last = segs.pop();
+    while (segs.length && segs.at(-1)?.slice(-1) === "\\") {
+      last = `${segs.pop().slice(0, -1)}.${last}`;
+    }
+    let target = obj;
+    while (segs.length) {
+      const seg = segs.shift();
+      if (isUnsafeKey(seg)) return false;
+      target = target[seg];
+    }
+    return delete target[last ?? ""];
+  }
+  return true;
+};
+const omitDeep = (value, keys) => {
+  if (value === void 0) return {};
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = omitDeep(value[i], keys);
+    }
+    return value;
+  }
+  if (!isPlainObject(value)) return value;
+  const omitKeys = typeof keys === "string" ? [keys] : keys;
+  if (!Array.isArray(omitKeys)) return value;
+  for (const key of omitKeys) {
+    unset(value, key);
+  }
+  for (const key of Object.keys(value)) {
+    value[key] = omitDeep(value[key], omitKeys);
+  }
+  return value;
+};
+
+const isPatchHistoryEnabled = (opts, context) => {
   return !opts.patchHistoryDisabled && !context.ignorePatchHistory;
-}
-function getJsonOmit(opts, doc) {
+};
+const getJsonOmit = (opts, doc) => {
   const object = JSON.parse(JSON.stringify(doc));
   if (opts.omit) {
-    return omit(object, opts.omit);
+    return omitDeep(object, opts.omit);
   }
   return object;
-}
-function getObjectOmit(opts, doc) {
+};
+const getObjectOmit = (opts, doc) => {
   if (opts.omit) {
-    return omit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit);
+    return omitDeep(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit);
   }
   return doc;
-}
-async function getUser(opts, doc) {
+};
+const getUser = async (opts, doc) => {
   if (isFunction(opts.getUser)) {
     return await opts.getUser(doc);
   }
   return void 0;
-}
-async function getReason(opts, doc) {
+};
+const getReason = async (opts, doc) => {
   if (isFunction(opts.getReason)) {
     return await opts.getReason(doc);
   }
   return void 0;
-}
-async function getMetadata(opts, doc) {
+};
+const getMetadata = async (opts, doc) => {
   if (isFunction(opts.getMetadata)) {
     return await opts.getMetadata(doc);
   }
   return void 0;
-}
-function getValue(item) {
+};
+const getValue = (item) => {
   return item.status === "fulfilled" ? item.value : void 0;
-}
-async function getData(opts, doc) {
+};
+const getData = async (opts, doc) => {
   return Promise.allSettled([getUser(opts, doc), getReason(opts, doc), getMetadata(opts, doc)]).then(([user, reason, metadata]) => {
     return [getValue(user), getValue(reason), getValue(metadata)];
   });
-}
-function emitEvent(context, event, data) {
+};
+const emitEvent = (context, event, data) => {
   if (event && !context.ignoreEvent) {
     em.emit(event, data);
   }
-}
-async function bulkPatch(opts, context, eventKey, docsKey) {
+};
+const bulkPatch = async (opts, context, eventKey, docsKey) => {
   const history = isPatchHistoryEnabled(opts, context);
   const event = opts[eventKey];
   const docs = context[docsKey];
   const key = eventKey === "eventCreated" ? "doc" : "oldDoc";
-  if (isEmpty(docs) || !event && !history) return;
+  if (isEmpty(docs) || !docs || !event && !history) return;
   const chunks = chunk(docs, 1e3);
-  for (const chunk2 of chunks) {
+  for (const batch of chunks) {
     const bulk = [];
-    for (const doc of chunk2) {
+    for (const doc of batch) {
       emitEvent(context, event, { [key]: doc });
       if (history) {
         const [user, reason, metadata] = await getData(opts, doc);
@@ -180,11 +400,11 @@ async function bulkPatch(opts, context, eventKey, docsKey) {
       });
     }
   }
-}
-async function createPatch(opts, context) {
+};
+const createPatch = async (opts, context) => {
   await bulkPatch(opts, context, "eventCreated", "createdDocs");
-}
-async function updatePatch(opts, context, current, original) {
+};
+const updatePatch = async (opts, context, current, original) => {
   const history = isPatchHistoryEnabled(opts, context);
   const currentObject = getJsonOmit(opts, current);
   const originalObject = getJsonOmit(opts, original);
@@ -211,10 +431,10 @@ async function updatePatch(opts, context, current, original) {
       ...metadata !== void 0 && { metadata }
     });
   }
-}
-async function deletePatch(opts, context) {
+};
+const deletePatch = async (opts, context) => {
   await bulkPatch(opts, context, "eventDeleted", "deletedDocs");
-}
+};
 
 const deleteMethods = ["remove", "findOneAndDelete", "findOneAndRemove", "findByIdAndDelete", "findByIdAndRemove", "deleteOne", "deleteMany"];
 const deleteHooksInitialize = (schema, opts) => {
@@ -277,12 +497,12 @@ const saveHooksInitialize = (schema, opts) => {
 const updateMethods = ["update", "updateOne", "replaceOne", "updateMany", "findOneAndUpdate", "findOneAndReplace", "findByIdAndUpdate"];
 const assignUpdate = (document, update, commands) => {
   let updated = assign(document.toObject(toObjectOptions), update);
-  forEach(commands, (command) => {
+  for (const command of commands) {
     try {
       updated = assign(updated, command);
     } catch {
     }
-  });
+  }
   const doc = document.set(updated).toObject(toObjectOptions);
   if (update.createdAt) doc.createdAt = update.createdAt;
   return doc;
@@ -292,12 +512,12 @@ const splitUpdateAndCommands = (updateQuery) => {
   const commands = [];
   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] });
         delete update[key];
-      });
+      }
     }
   }
   return { update, commands };
@@ -342,7 +562,6 @@ const updateHooksInitialize = (schema, opts) => {
       current = await model.findOne(combined).sort("desc").lean().exec();
     }
     if (!isEmpty(filter) && !current) {
-      console.log("filter", filter);
       current = await model.findOne(filter).sort("desc").lean().exec();
     }
     if (current) {
@@ -352,15 +571,16 @@ const updateHooksInitialize = (schema, opts) => {
   });
 };
 
-const isMongooseLessThan8 = satisfies(mongoose.version, "<8");
-const isMongooseLessThan7 = satisfies(mongoose.version, "<7");
-const isMongoose6 = satisfies(mongoose.version, "6");
+const major = Number.parseInt(mongoose.version, 10);
+const isMongooseLessThan8 = major < 8;
+const isMongooseLessThan7 = major < 7;
+const isMongoose6 = major === 6;
 if (isMongoose6) {
   mongoose.set("strictQuery", false);
 }
 
 const remove = isMongooseLessThan7 ? "remove" : "deleteOne";
-const patchHistoryPlugin = function plugin(schema, opts) {
+const patchHistoryPlugin = (schema, opts) => {
   saveHooksInitialize(schema, opts);
   updateHooksInitialize(schema, opts);
   deleteHooksInitialize(schema, opts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-patch-mongoose",
-  "version": "2.9.6",
+  "version": "3.0.0",
   "description": "Patch history & events for mongoose models",
   "author": "ilovepixelart",
   "license": "MIT",
@@ -36,7 +36,7 @@
     "log"
   ],
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "files": [
     "dist",
@@ -71,28 +71,21 @@
     "release": "npm install && npm run biome && npm run type:check && npm run build && np --no-publish"
   },
   "dependencies": {
-    "@types/lodash": "4.17.24",
-    "@types/ms": "2.1.0",
-    "@types/semver": "7.7.1",
     "fast-json-patch": "3.1.1",
-    "lodash": "4.17.23",
-    "ms": "2.1.3",
-    "omit-deep": "0.3.0",
-    "power-assign": "0.2.10",
-    "semver": "7.7.4"
+    "power-assign": "0.2.10"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.4",
-    "@types/node": "25.3.0",
-    "@vitest/coverage-v8": "4.0.18",
+    "@biomejs/biome": "2.4.7",
+    "@types/node": "25.5.0",
+    "@vitest/coverage-v8": "4.1.0",
     "mongodb-memory-server": "11.0.1",
-    "mongoose": "9.2.2",
+    "mongoose": "9.3.0",
+    "np": "11.0.2",
     "open-cli": "8.0.0",
-    "pkgroll": "2.26.3",
+    "pkgroll": "2.27.0",
     "simple-git-hooks": "2.13.1",
     "typescript": "5.9.3",
-    "vitest": "4.0.18",
-    "np": "11.0.2"
+    "vitest": "4.1.0"
   },
   "peerDependencies": {
     "mongoose": ">=6.6.0 < 10"
@@ -105,6 +98,7 @@
     "publish": false
   },
   "overrides": {
-    "esbuild": "0.25.0"
+    "tmp": "0.2.5",
+    "file-type": "21.3.2"
   }
 }

package/src/helpers.ts

@@ -1,8 +1,122 @@
-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 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
+
+  if ('toJSON' in value && typeof (value as Record<string, unknown>).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 +126,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): 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,16 +147,13 @@ 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)

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 { isArray, isEmpty, isHookIgnored } from '../helpers'
 import { deletePatch } from '../patch'
 
 import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema } from 'mongoose'