ts-patch-mongoose 3.0.0 → 3.1.2

package/README.md

@@ -15,16 +15,16 @@ Patch history (audit log) & events plugin for mongoose
 
 ## 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 || 7.x || 8.x || 9.x",
 }
 ```
 
@@ -53,9 +53,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,33 +77,34 @@ 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 })
@@ -117,25 +118,25 @@ BookSchema.plugin(patchHistoryPlugin, {
   // 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 +144,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 +194,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

@@ -100,9 +100,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;
@@ -140,6 +141,12 @@ const cloneImmutable = (value) => {
       cloned.lastIndex = re.lastIndex;
       return cloned;
     }
+    case "[object Error]": {
+      const err = value;
+      const cloned = new err.constructor(err.message);
+      if (err.stack) cloned.stack = err.stack;
+      return cloned;
+    }
     case "[object ArrayBuffer]":
       return cloneArrayBuffer(value);
     case "[object DataView]": {
@@ -188,7 +195,11 @@ const cloneDeep = (value, seen = /* @__PURE__ */ new WeakMap()) => {
   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") {
+  const record = value;
+  if (typeof record._bsontype === "string" && typeof record.toHexString === "function") {
+    return new value.constructor(record.toHexString());
+  }
+  if (typeof record.toJSON === "function") {
     return JSON.parse(JSON.stringify(value));
   }
   return cloneCollection(value, seen);
@@ -207,7 +218,7 @@ const toObjectOptions = {
   depopulate: true,
   virtuals: false
 };
-const setPatchHistoryTTL = async (ttl) => {
+const setPatchHistoryTTL = async (ttl, onError) => {
   const name = "createdAt_1_TTL";
   try {
     const indexes = await HistoryModel.collection.indexes();
@@ -230,7 +241,8 @@ const setPatchHistoryTTL = async (ttl) => {
     }
     await HistoryModel.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds, name });
   } catch (err) {
-    console.error("Couldn't create or update index for history collection", err);
+    const handler = onError ?? console.error;
+    handler(err);
   }
 };
 
@@ -246,113 +258,65 @@ const isPlainObject = (val) => {
 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];
+const classifyKeys = (omitKeys) => {
+  const topLevel = /* @__PURE__ */ new Set();
+  const nested = /* @__PURE__ */ new Map();
+  for (const key of omitKeys) {
+    const dotIdx = key.indexOf(".");
+    if (dotIdx === -1) {
+      topLevel.add(key);
+    } else {
+      const head = key.slice(0, dotIdx);
+      const tail = key.slice(dotIdx + 1);
+      if (!isUnsafeKey(head)) {
+        const existing = nested.get(head) ?? [];
+        existing.push(tail);
+        nested.set(head, existing);
+      }
     }
-    return delete target[last ?? ""];
   }
-  return true;
+  return { topLevel, nested };
 };
 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;
+    return value.map((item) => omitDeep(item, keys));
   }
   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);
-  }
+  const { topLevel, nested } = classifyKeys(omitKeys);
+  const result = {};
   for (const key of Object.keys(value)) {
-    value[key] = omitDeep(value[key], omitKeys);
+    if (topLevel.has(key)) continue;
+    const nestedKeys = nested.get(key);
+    result[key] = omitDeep(value[key], nestedKeys ?? omitKeys);
   }
-  return value;
+  return result;
 };
 
 const isPatchHistoryEnabled = (opts, context) => {
   return !opts.patchHistoryDisabled && !context.ignorePatchHistory;
 };
+const applyOmit = (object, opts) => {
+  return opts.omit ? omitDeep(object, opts.omit) : object;
+};
+const replacer = (_key, value) => typeof value === "bigint" ? value.toString() : value;
 const getJsonOmit = (opts, doc) => {
-  const object = JSON.parse(JSON.stringify(doc));
-  if (opts.omit) {
-    return omitDeep(object, opts.omit);
-  }
-  return object;
+  return applyOmit(JSON.parse(JSON.stringify(doc, replacer)), opts);
 };
 const getObjectOmit = (opts, doc) => {
-  if (opts.omit) {
-    return omitDeep(isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit);
-  }
-  return doc;
-};
-const getUser = async (opts, doc) => {
-  if (isFunction(opts.getUser)) {
-    return await opts.getUser(doc);
-  }
-  return void 0;
-};
-const getReason = async (opts, doc) => {
-  if (isFunction(opts.getReason)) {
-    return await opts.getReason(doc);
-  }
-  return void 0;
+  return applyOmit(isFunction(doc?.toObject) ? doc.toObject() : doc, opts);
 };
-const getMetadata = async (opts, doc) => {
-  if (isFunction(opts.getMetadata)) {
-    return await opts.getMetadata(doc);
+const getOptionalField = async (fn, doc) => {
+  if (isFunction(fn)) {
+    return await fn(doc);
   }
   return void 0;
 };
+const getUser = async (opts, doc) => getOptionalField(opts.getUser, doc);
+const getReason = async (opts, doc) => getOptionalField(opts.getReason, doc);
+const getMetadata = async (opts, doc) => getOptionalField(opts.getMetadata, doc);
 const getValue = (item) => {
   return item.status === "fulfilled" ? item.value : void 0;
 };
@@ -363,7 +327,10 @@ const getData = async (opts, doc) => {
 };
 const emitEvent = (context, event, data) => {
   if (event && !context.ignoreEvent) {
-    em.emit(event, data);
+    try {
+      em.emit(event, data);
+    } catch {
+    }
   }
 };
 const bulkPatch = async (opts, context, eventKey, docsKey) => {
@@ -376,7 +343,8 @@ const bulkPatch = async (opts, context, eventKey, docsKey) => {
   for (const batch of chunks) {
     const bulk = [];
     for (const doc of batch) {
-      emitEvent(context, event, { [key]: doc });
+      const omitted = getObjectOmit(opts, doc);
+      emitEvent(context, event, { [key]: omitted });
       if (history) {
         const [user, reason, metadata] = await getData(opts, doc);
         bulk.push({
@@ -386,7 +354,7 @@ const bulkPatch = async (opts, context, eventKey, docsKey) => {
               modelName: context.modelName,
               collectionName: context.collectionName,
               collectionId: doc._id,
-              doc: getObjectOmit(opts, doc),
+              doc: omitted,
               version: 0,
               ...user !== void 0 && { user },
               ...reason !== void 0 && { reason },
@@ -397,8 +365,9 @@ const bulkPatch = async (opts, context, eventKey, docsKey) => {
       }
     }
     if (history && !isEmpty(bulk)) {
+      const onError = opts.onError ?? console.error;
       await HistoryModel.bulkWrite(bulk, { ordered: false }).catch((error) => {
-        console.error(error.message);
+        onError(error);
       });
     }
   }
@@ -417,10 +386,11 @@ const updatePatch = async (opts, context, current, original) => {
   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);
+    const onError = opts.onError ?? console.error;
     await HistoryModel.create({
       op: context.op,
       modelName: context.modelName,
@@ -431,6 +401,8 @@ const updatePatch = async (opts, context, current, original) => {
       ...user !== void 0 && { user },
       ...reason !== void 0 && { reason },
       ...metadata !== void 0 && { metadata }
+    }).catch((error) => {
+      onError(error);
     });
   }
 };
@@ -447,8 +419,8 @@ const deleteHooksInitialize = (schema, opts) => {
     const filter = this.getFilter();
     this._context = {
       op: this.op,
-      modelName: opts.modelName ?? this.model.modelName,
-      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
       ignoreEvent: options.ignoreEvent,
       ignorePatchHistory: options.ignorePatchHistory
     };
@@ -464,12 +436,13 @@ const deleteHooksInitialize = (schema, opts) => {
       }
     }
     if (opts.preDelete && isArray(this._context.deletedDocs) && !isEmpty(this._context.deletedDocs)) {
-      await opts.preDelete(this._context.deletedDocs);
+      await opts.preDelete(cloneDeep(this._context.deletedDocs));
     }
   });
   schema.post(deleteMethods, { document: false, query: true }, async function() {
     const options = this.getOptions();
     if (isHookIgnored(options)) return;
+    if (!this._context) return;
     await deletePatch(opts, this._context);
   });
 };
@@ -497,15 +470,42 @@ const saveHooksInitialize = (schema, opts) => {
 };
 
 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] = 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);
+  const changedByCommand = /* @__PURE__ */ new Map();
   for (const command of commands) {
+    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);
+      }
     }
   }
   const doc = document.set(updated).toObject(toObjectOptions);
+  for (const [field, value] of changedByCommand) {
+    doc[field] = value;
+  }
   if (update.createdAt) doc.createdAt = update.createdAt;
   return doc;
 };
@@ -525,17 +525,16 @@ const splitUpdateAndCommands = (updateQuery) => {
   return { update, commands };
 };
 const updateHooksInitialize = (schema, opts) => {
-  schema.pre(updateMethods, async function() {
+  schema.pre(updateMethods, { document: false, query: true }, async function() {
     const options = this.getOptions();
     if (isHookIgnored(options)) return;
     const model = this.model;
     const filter = this.getFilter();
-    const count = await this.model.countDocuments(filter).exec();
     this._context = {
       op: this.op,
-      modelName: opts.modelName ?? this.model.modelName,
-      collectionName: opts.collectionName ?? this.model.collection.collectionName,
-      isNew: Boolean(options.upsert) && count === 0,
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
+      isNew: Boolean(options.upsert) && await model.countDocuments(filter).exec() === 0,
       ignoreEvent: options.ignoreEvent,
       ignorePatchHistory: options.ignorePatchHistory
     };
@@ -547,24 +546,21 @@ const updateHooksInitialize = (schema, opts) => {
       await updatePatch(opts, this._context, assignUpdate(doc, update, commands), origDoc);
     });
   });
-  schema.post(updateMethods, async function() {
+  schema.post(updateMethods, { document: false, query: true }, async function() {
     const options = this.getOptions();
     if (isHookIgnored(options)) return;
+    if (!this._context) return;
     if (!this._context.isNew) return;
     const model = this.model;
     const updateQuery = this.getUpdate();
     const { update, commands } = splitUpdateAndCommands(updateQuery);
-    let current = null;
     const filter = this.getFilter();
-    const combined = assignUpdate(model.hydrate({}), update, commands);
-    if (!isEmpty(update) && !current) {
-      current = await model.findOne(update).sort("desc").lean().exec();
-    }
-    if (!isEmpty(combined) && !current) {
-      current = await model.findOne(combined).sort("desc").lean().exec();
-    }
-    if (!isEmpty(filter) && !current) {
-      current = await model.findOne(filter).sort("desc").lean().exec();
+    const candidates = [update, assignUpdate(model.hydrate({}), update, commands), filter];
+    let current = null;
+    for (const query of candidates) {
+      if (current || isEmpty(query)) continue;
+      const found = await model.findOne(query).sort({ _id: -1 }).lean().exec();
+      current = found;
     }
     if (current) {
       this._context.createdDocs = [current];
@@ -596,13 +592,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

@@ -13,6 +13,8 @@ interface History {
     reason?: string;
     metadata?: object;
     patch?: Operation[];
+    createdAt?: Date;
+    updatedAt?: Date;
 }
 interface PatchEvent<T> {
     oldDoc?: HydratedDocument<T>;
@@ -47,6 +49,7 @@ interface PluginOptions<T> {
     omit?: string[];
     patchHistoryDisabled?: boolean;
     preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>;
+    onError?: (error: Error) => void;
 }
 
 declare class PatchEventEmitter extends EventEmitter {
@@ -92,7 +95,7 @@ declare const UNITS: {
 type Unit = keyof typeof UNITS;
 type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`;
 
-declare const setPatchHistoryTTL: (ttl: Duration) => Promise<void>;
+declare const setPatchHistoryTTL: (ttl: Duration, onError?: (error: Error) => void) => Promise<void>;
 
 declare const patchHistoryPlugin: <T>(schema: Schema<T>, opts: PluginOptions<T>) => void;
 

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;;;AChDtD,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;ACiFpF,cAAa,kBAAkB,QAAe,QAAQ,KAAG,OAAO;;AC9GhE,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}
+{"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;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

@@ -13,6 +13,8 @@ interface History {
     reason?: string;
     metadata?: object;
     patch?: Operation[];
+    createdAt?: Date;
+    updatedAt?: Date;
 }
 interface PatchEvent<T> {
     oldDoc?: HydratedDocument<T>;
@@ -47,6 +49,7 @@ interface PluginOptions<T> {
     omit?: string[];
     patchHistoryDisabled?: boolean;
     preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>;
+    onError?: (error: Error) => void;
 }
 
 declare class PatchEventEmitter extends EventEmitter {
@@ -92,7 +95,7 @@ declare const UNITS: {
 type Unit = keyof typeof UNITS;
 type Duration = number | `${number}` | `${number}${Unit}` | `${number} ${Unit}`;
 
-declare const setPatchHistoryTTL: (ttl: Duration) => Promise<void>;
+declare const setPatchHistoryTTL: (ttl: Duration, onError?: (error: Error) => void) => Promise<void>;
 
 declare const patchHistoryPlugin: <T>(schema: Schema<T>, opts: PluginOptions<T>) => void;
 

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;;;AChDtD,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;ACiFpF,cAAa,kBAAkB,QAAe,QAAQ,KAAG,OAAO;;AC9GhE,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}
+{"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;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":[]}