ts-patch-mongoose 3.1.0 → 4.0.0

package/README.md

@@ -12,22 +12,28 @@ Patch history (audit log) & events plugin for mongoose
 [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-patch-mongoose&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-patch-mongoose)
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-patch-mongoose&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-patch-mongoose)
 [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-patch-mongoose&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-patch-mongoose)
+\
+[![Socket Badge](https://badge.socket.dev/npm/package/ts-patch-mongoose)](https://socket.dev/npm/package/ts-patch-mongoose)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/ilovepixelart/ts-patch-mongoose/badge)](https://securityscorecards.dev/viewer/?uri=github.com/ilovepixelart/ts-patch-mongoose)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12473/badge)](https://www.bestpractices.dev/en/projects/12473)
 
 ## Motivation
 
-ts-patch-mongoose is a plugin for mongoose
+ts-patch-mongoose is a plugin for mongoose.
 \
-I need to track changes of mongoose models and save them as patch history (audit log) in separate collection. Changes must also emit events that I can subscribe to and react in other parts of my application. I also want to omit some fields from patch history.
+I need to track changes of mongoose models and save them as patch history (audit log) in a separate collection. Changes must also emit events that I can subscribe to and react in other parts of my application. I also want to omit some fields from patch history.
 
 ## Supports and tested with
 
 ```json
 {
   "node": "20.x || 22.x || 24.x",
-  "mongoose": ">=6.6.x || 7.x || 8.x || 9.x",
+  "mongoose": ">=6.6.0 <10"
 }
 ```
 
+CI tests against mongoose `6.12.2`, `7.6.4`, `8.23.0`, and `9.4.1`.
+
 ## Features
 
 - Track changes in mongoose models
@@ -53,9 +59,9 @@ bun add ts-patch-mongoose mongoose
 
 Works with any Node.js framework — Express, Fastify, Koa, Hono, Nest, etc.
 \
-How to use it with express [ts-express-tsx](https://github.com/ilovepixelart/ts-express-tsx)
+How to use it with Express: [ts-express-tsx](https://github.com/ilovepixelart/ts-express-tsx)
 
-Create your event constants `events.ts`
+Create your event constants in `events.ts`
 
 ```typescript
 export const BOOK_CREATED = 'book-created'
@@ -77,65 +83,66 @@ export type Book = {
 }
 ```
 
-Setup your mongoose model `Book.ts`
+Set up your mongoose model in `Book.ts`
 
 ```typescript
 import { Schema, model } from 'mongoose'
 
-import type { HydratedDocument, Types } from 'mongoose'
+import type { HydratedDocument } from 'mongoose'
 import type { Book } from '../types'
 
 import { patchHistoryPlugin, setPatchHistoryTTL } from 'ts-patch-mongoose'
 import { BOOK_CREATED, BOOK_UPDATED, BOOK_DELETED } from '../constants/events'
 
-// You can set patch history TTL in plain english or in milliseconds as you wish.
+// You can set patch history TTL in plain English or in milliseconds as you wish.
 // This will determine how long you want to keep patch history.
 // You don't need to use this global config in case you want to keep patch history forever.
-// Execute this method after you connected to you database somewhere in your application.
-setPatchHistoryTTL('1 month')
+// Execute this method after you connected to your database somewhere in your application.
+// Optional second argument for custom error handling
+setPatchHistoryTTL('1 month', (error) => console.error('TTL setup failed:', error))
 
 const BookSchema = new Schema<Book>({
-  name: {
-    title: String,
+  title: {
+    type: String,
     required: true
   },
   description: {
     type: String,
   },
   authorId: {
-    type: Types.ObjectId,
+    type: Schema.Types.ObjectId,
     required: true
   }
 }, { timestamps: true })
 
-BookSchema.plugin(patchHistoryPlugin, { 
+BookSchema.plugin(patchHistoryPlugin, {
   // Provide your event constants to plugin
   eventCreated: BOOK_CREATED,
   eventUpdated: BOOK_UPDATED,
   eventDeleted: BOOK_DELETED,
-  
+
   // You can omit some properties in case you don't want to save them to patch history
   omit: ['__v', 'createdAt', 'updatedAt'],
 
-  // Addition options for patchHistoryPlugin plugin
-  // Everything bellow is optional and just shows you what you can do:
+  // Additional options for patchHistoryPlugin
+  // Everything below is optional and just shows you what you can do:
 
-  // Code bellow is abstract example, you can use any other way to get user, reason, metadata
-  // These three properties will be added to patch history document automatically and give you flexibility to track who, why and when made changes to your documents
+  // Code below is an abstract example, you can use any other way to get user, reason, metadata
+  // These three properties will be added to patch history document automatically and gives you flexibility to track who, why and when made changes to your documents
   getUser: async (doc: HydratedDocument<Book>) => {
     // For example: get user from http context
     // You should return an object, in case you want to save user to patch history
     return httpContext.get('user') as Record<string, unknown>
   },
 
-  // Reason of document (create/update/delete) like: 'Excel upload', 'Manual update', 'API call', etc.
+  // Reason for the document change (create/update/delete) like: 'Excel upload', 'Manual update', 'API call', etc.
   getReason: async (doc: HydratedDocument<Book>) => {
     // For example: get reason from http context, or any other place of your application
-    // You shout return a string, in case you want to save reason to patch history
+    // You should return a string, in case you want to save reason to patch history
     return httpContext.get('reason') as string
   },
 
-  // You can provide any information you want to save in along with patch history
+  // You can provide any information you want to save along with patch history
   getMetadata: async (doc: HydratedDocument<Book>) => {
     // For example: get metadata from http context, or any other place of your application
     // You should return an object, in case you want to save metadata to patch history
@@ -143,15 +150,20 @@ BookSchema.plugin(patchHistoryPlugin, {
   },
 
   // Do something before deleting documents
-  // This method will be executed before deleting document or documents and always returns a nonempty array of documents
+  // This method will be executed before deleting document or documents and always returns a non-empty array of documents
   preDelete: async (docs) => {
     const bookIds = docs.map((doc) => doc._id)
     await SomeOtherModel.deleteMany({ bookId: { $in: bookIds } })
   },
 
-  // In case you just want to track changes in your models using events below.
-  // And don't want to save changes to patch history collection
-  patchHistoryDisabled: true, 
+  // Custom error handler for history write failures (defaults to console.error)
+  onError: (error) => {
+    console.error('Patch history error:', error)
+  },
+
+  // In case you just want to track changes in your models using events
+  // and don't want to save changes to patch history collection
+  // patchHistoryDisabled: true,
 })
 
 const Book = model('Book', BookSchema)
@@ -188,7 +200,7 @@ patchEventEmitter.on(BOOK_UPDATED, ({ doc, oldDoc, patch }) => {
 patchEventEmitter.on(BOOK_DELETED, ({ oldDoc }) => {
   try {
     console.log('Event - book deleted', oldDoc)
-    // Do something with doc here
+    // Do something with oldDoc here
   } catch (error) {
     console.error(error)
   }

package/dist/index.cjs

@@ -1,9 +1,7 @@
 'use strict';
 
 var mongoose = require('mongoose');
-var jsonpatch = require('fast-json-patch');
 var EventEmitter = require('node:events');
-var powerAssign = require('power-assign');
 
 const HistorySchema = new mongoose.Schema(
   {
@@ -100,9 +98,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;
@@ -249,6 +248,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);
@@ -379,13 +466,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);
@@ -468,38 +555,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 = powerAssign.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 = powerAssign.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) {
@@ -554,11 +805,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];
@@ -590,13 +844,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/dist/index.d.cts

@@ -1,7 +1,27 @@
 import { Types, Query, HydratedDocument, Schema } from 'mongoose';
-import { Operation } from 'fast-json-patch';
 import EventEmitter from 'node:events';
 
+interface AddOperation<T> {
+    op: 'add';
+    path: string;
+    value: T;
+}
+interface RemoveOperation {
+    op: 'remove';
+    path: string;
+}
+interface ReplaceOperation<T> {
+    op: 'replace';
+    path: string;
+    value: T;
+}
+interface TestOperation<T> {
+    op: 'test';
+    path: string;
+    value: T;
+}
+type Operation = AddOperation<unknown> | RemoveOperation | ReplaceOperation<unknown> | TestOperation<unknown>;
+
 interface History {
     op: string;
     modelName: string;
@@ -13,6 +33,8 @@ interface History {
     reason?: string;
     metadata?: object;
     patch?: Operation[];
+    createdAt?: Date;
+    updatedAt?: Date;
 }
 interface PatchEvent<T> {
     oldDoc?: HydratedDocument<T>;

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;;AAGM,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;;AAGb,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACjDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}
+{"version":3,"file":"index.d.cts","sources":["../src/json-patch.ts","../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;AAAM,UAAW,YAAY;;;;;AAMvB,UAAW,eAAe;;;;AAK1B,UAAW,gBAAgB;;;;;AAM3B,UAAW,aAAa;;;;;AAMxB,KAAM,SAAS,GAAG,YAAY,YAAY,eAAe,GAAG,gBAAgB,YAAY,aAAa;;ACpBrG,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;gBACL,IAAI;gBACJ,IAAI;;AAGZ,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACnDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}

package/dist/index.d.mts

@@ -1,7 +1,27 @@
 import { Types, Query, HydratedDocument, Schema } from 'mongoose';
-import { Operation } from 'fast-json-patch';
 import EventEmitter from 'node:events';
 
+interface AddOperation<T> {
+    op: 'add';
+    path: string;
+    value: T;
+}
+interface RemoveOperation {
+    op: 'remove';
+    path: string;
+}
+interface ReplaceOperation<T> {
+    op: 'replace';
+    path: string;
+    value: T;
+}
+interface TestOperation<T> {
+    op: 'test';
+    path: string;
+    value: T;
+}
+type Operation = AddOperation<unknown> | RemoveOperation | ReplaceOperation<unknown> | TestOperation<unknown>;
+
 interface History {
     op: string;
     modelName: string;
@@ -13,6 +33,8 @@ interface History {
     reason?: string;
     metadata?: object;
     patch?: Operation[];
+    createdAt?: Date;
+    updatedAt?: Date;
 }
 interface PatchEvent<T> {
     oldDoc?: HydratedDocument<T>;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sources":["../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;;AAGM,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;;AAGb,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACjDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}
+{"version":3,"file":"index.d.mts","sources":["../src/json-patch.ts","../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;AAAM,UAAW,YAAY;;;;;AAMvB,UAAW,eAAe;;;;AAK1B,UAAW,gBAAgB;;;;;AAM3B,UAAW,aAAa;;;;;AAMxB,KAAM,SAAS,GAAG,YAAY,YAAY,eAAe,GAAG,gBAAgB,YAAY,aAAa;;ACpBrG,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;gBACL,IAAI;gBACJ,IAAI;;AAGZ,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACnDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}