ts-patch-mongoose 2.8.0 → 2.8.1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024 ilovepixelart
+Copyright (c) 2025 ilovepixelart
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -30,13 +30,13 @@ I need to track changes of mongoose models and save them as patch history (audit
 
 ## Features
 
-- [x] Track changes in mongoose models
-- [x] Save changes in a separate collection as a patch history
-- [x] Emit events when a model is created, updated or deleted
-- [x] Omit fields that you don't want to track in patch history
-- [x] Subscribe to one/many types of event
-- [x] Use events or patch history or both
-- [x] Supports ESM and CommonJS
+- Track changes in mongoose models
+- Save changes in a separate collection as a patch history
+- Emit events when a model is created, updated or deleted
+- Omit fields that you don't want to track in patch history
+- Subscribe to one/many types of event
+- Use events or patch history or both
+- Supports ESM and CommonJS
 
 ## Installation
 
@@ -71,7 +71,7 @@ bun add mongoose@8
 
 ## Example
 
-How to use it with express [ts-express-swc](https://github.com/ilovepixelart/ts-express-swc)
+How to use it with express [ts-express-tsx](https://github.com/ilovepixelart/ts-express-tsx)
 
 Create your event constants `events.ts`
 

package/dist/index.cjs

@@ -0,0 +1,395 @@
+'use strict';
+
+var _ = require('lodash');
+var EventEmitter = require('node:events');
+var ms = require('ms');
+var mongoose = require('mongoose');
+var jsonpatch = require('fast-json-patch');
+var omit = require('omit-deep');
+var semver = require('semver');
+var powerAssign = require('power-assign');
+
+class PatchEventEmitter extends EventEmitter {
+}
+const em = new PatchEventEmitter();
+
+const HistorySchema = new mongoose.Schema(
+  {
+    op: {
+      type: String,
+      required: true
+    },
+    modelName: {
+      type: String,
+      required: true
+    },
+    collectionName: {
+      type: String,
+      required: true
+    },
+    collectionId: {
+      type: mongoose.Schema.Types.ObjectId,
+      required: true
+    },
+    doc: {
+      type: Object
+    },
+    patch: {
+      type: Array
+    },
+    user: {
+      type: Object
+    },
+    reason: {
+      type: String
+    },
+    metadata: {
+      type: Object
+    },
+    version: {
+      type: Number,
+      min: 0,
+      default: 0
+    }
+  },
+  { timestamps: true }
+);
+HistorySchema.index({ collectionId: 1, version: -1 });
+HistorySchema.index({ op: 1, modelName: 1, collectionName: 1, collectionId: 1, reason: 1, version: 1 });
+const HistoryModel = mongoose.model("History", HistorySchema, "history");
+
+const isHookIgnored = (options) => {
+  return options.ignoreHook === true || options.ignoreEvent === true && options.ignorePatchHistory === true;
+};
+const toObjectOptions = {
+  depopulate: true,
+  virtuals: false
+};
+const setPatchHistoryTTL = async (ttl) => {
+  const name = "createdAt_1_TTL";
+  try {
+    const indexes = await HistoryModel.collection.indexes();
+    const existingIndex = indexes?.find((index) => index.name === name);
+    if (!ttl && existingIndex) {
+      await HistoryModel.collection.dropIndex(name);
+      return;
+    }
+    const milliseconds = typeof ttl === "string" ? ms(ttl) : ttl;
+    if (milliseconds < 1e3 && existingIndex) {
+      await HistoryModel.collection.dropIndex(name);
+      return;
+    }
+    const expireAfterSeconds = milliseconds / 1e3;
+    if (existingIndex && existingIndex.expireAfterSeconds === expireAfterSeconds) {
+      return;
+    }
+    if (existingIndex) {
+      await HistoryModel.collection.dropIndex(name);
+    }
+    await HistoryModel.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds, name });
+  } catch (err) {
+    console.error("Couldn't create or update index for history collection", err);
+  }
+};
+
+function isPatchHistoryEnabled(opts, context) {
+  return !opts.patchHistoryDisabled && !context.ignorePatchHistory;
+}
+function getJsonOmit(opts, doc) {
+  const object = JSON.parse(JSON.stringify(doc));
+  if (opts.omit) {
+    return omit(object, opts.omit);
+  }
+  return object;
+}
+function getObjectOmit(opts, doc) {
+  if (opts.omit) {
+    return omit(_.isFunction(doc?.toObject) ? doc.toObject() : doc, opts.omit);
+  }
+  return doc;
+}
+async function getUser(opts) {
+  if (_.isFunction(opts.getUser)) {
+    return await opts.getUser();
+  }
+  return void 0;
+}
+async function getReason(opts) {
+  if (_.isFunction(opts.getReason)) {
+    return await opts.getReason();
+  }
+  return void 0;
+}
+async function getMetadata(opts) {
+  if (_.isFunction(opts.getMetadata)) {
+    return await opts.getMetadata();
+  }
+  return void 0;
+}
+function getValue(item) {
+  return item.status === "fulfilled" ? item.value : void 0;
+}
+async function getData(opts) {
+  return Promise.allSettled([getUser(opts), getReason(opts), getMetadata(opts)]).then(([user, reason, metadata]) => {
+    return [getValue(user), getValue(reason), getValue(metadata)];
+  });
+}
+function emitEvent(context, event, data) {
+  if (event && !context.ignoreEvent) {
+    em.emit(event, data);
+  }
+}
+async function bulkPatch(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;
+  const [user, reason, metadata] = await getData(opts);
+  const chunks = _.chunk(docs, 1e3);
+  for await (const chunk of chunks) {
+    const bulk = [];
+    for (const doc of chunk) {
+      emitEvent(context, event, { [key]: doc });
+      if (history) {
+        bulk.push({
+          insertOne: {
+            document: {
+              op: context.op,
+              modelName: context.modelName,
+              collectionName: context.collectionName,
+              collectionId: doc._id,
+              doc: getObjectOmit(opts, doc),
+              user,
+              reason,
+              metadata,
+              version: 0
+            }
+          }
+        });
+      }
+    }
+    if (history && !_.isEmpty(bulk)) {
+      await HistoryModel.bulkWrite(bulk, { ordered: false }).catch((error) => {
+        console.error(error.message);
+      });
+    }
+  }
+}
+async function createPatch(opts, context) {
+  await bulkPatch(opts, context, "eventCreated", "createdDocs");
+}
+async function updatePatch(opts, context, current, original) {
+  const history = isPatchHistoryEnabled(opts, context);
+  const currentObject = getJsonOmit(opts, current);
+  const originalObject = getJsonOmit(opts, original);
+  if (_.isEmpty(originalObject) || _.isEmpty(currentObject)) return;
+  const patch = jsonpatch.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) {
+      version = lastHistory.version + 1;
+    }
+    const [user, reason, metadata] = await getData(opts);
+    await HistoryModel.create({
+      op: context.op,
+      modelName: context.modelName,
+      collectionName: context.collectionName,
+      collectionId: original._id,
+      patch,
+      user,
+      reason,
+      metadata,
+      version
+    });
+  }
+}
+async function deletePatch(opts, context) {
+  await bulkPatch(opts, context, "eventDeleted", "deletedDocs");
+}
+
+const isMongooseLessThan8 = semver.satisfies(mongoose.version, "<8");
+const isMongooseLessThan7 = semver.satisfies(mongoose.version, "<7");
+const isMongoose6 = semver.satisfies(mongoose.version, "6");
+if (isMongoose6) {
+  mongoose.set("strictQuery", false);
+}
+
+const deleteMethods = ["remove", "findOneAndDelete", "findOneAndRemove", "findByIdAndDelete", "findByIdAndRemove", "deleteOne", "deleteMany"];
+const deleteHooksInitialize = (schema, opts) => {
+  schema.pre(deleteMethods, { document: false, query: true }, async function() {
+    const options = this.getOptions();
+    if (isHookIgnored(options)) return;
+    const model = this.model;
+    const filter = this.getFilter();
+    this._context = {
+      op: this.op,
+      modelName: opts.modelName ?? this.model.modelName,
+      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      ignoreEvent: options.ignoreEvent,
+      ignorePatchHistory: options.ignorePatchHistory
+    };
+    if (["remove", "deleteMany"].includes(this._context.op) && !options.single) {
+      const docs = await model.find(filter).lean().exec();
+      if (!_.isEmpty(docs)) {
+        this._context.deletedDocs = docs;
+      }
+    } else {
+      const doc = await model.findOne(filter).lean().exec();
+      if (!_.isEmpty(doc)) {
+        this._context.deletedDocs = [doc];
+      }
+    }
+    if (opts.preDelete && _.isArray(this._context.deletedDocs) && !_.isEmpty(this._context.deletedDocs)) {
+      await opts.preDelete(this._context.deletedDocs);
+    }
+  });
+  schema.post(deleteMethods, { document: false, query: true }, async function() {
+    const options = this.getOptions();
+    if (isHookIgnored(options)) return;
+    await deletePatch(opts, this._context);
+  });
+};
+
+const saveHooksInitialize = (schema, opts) => {
+  schema.pre("save", async function() {
+    if (this.constructor.name !== "model") return;
+    const current = this.toObject(toObjectOptions);
+    const model = this.constructor;
+    const context = {
+      op: this.isNew ? "create" : "update",
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName,
+      createdDocs: [current]
+    };
+    if (this.isNew) {
+      await createPatch(opts, context);
+    } else {
+      const original = await model.findById(current._id).lean().exec();
+      if (original) {
+        await updatePatch(opts, context, current, original);
+      }
+    }
+  });
+};
+
+const updateMethods = ["update", "updateOne", "replaceOne", "updateMany", "findOneAndUpdate", "findOneAndReplace", "findByIdAndUpdate"];
+const assignUpdate = (document, update, commands) => {
+  let updated = powerAssign.assign(document.toObject(toObjectOptions), update);
+  _.forEach(commands, (command) => {
+    try {
+      updated = powerAssign.assign(updated, command);
+    } catch {
+    }
+  });
+  const doc = document.set(updated).toObject(toObjectOptions);
+  if (update.createdAt) doc.createdAt = update.createdAt;
+  return doc;
+};
+const splitUpdateAndCommands = (updateQuery) => {
+  let update = {};
+  const commands = [];
+  if (!_.isEmpty(updateQuery) && !_.isArray(updateQuery) && _.isObjectLike(updateQuery)) {
+    update = _.cloneDeep(updateQuery);
+    const keysWithDollarSign = _.keys(update).filter((key) => key.startsWith("$"));
+    if (!_.isEmpty(keysWithDollarSign)) {
+      _.forEach(keysWithDollarSign, (key) => {
+        commands.push({ [key]: update[key] });
+        delete update[key];
+      });
+    }
+  }
+  return { update, commands };
+};
+const updateHooksInitialize = (schema, opts) => {
+  schema.pre(updateMethods, 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,
+      ignoreEvent: options.ignoreEvent,
+      ignorePatchHistory: options.ignorePatchHistory
+    };
+    const updateQuery = this.getUpdate();
+    const { update, commands } = splitUpdateAndCommands(updateQuery);
+    const cursor = model.find(filter).cursor();
+    await cursor.eachAsync(async (doc) => {
+      const origDoc = doc.toObject(toObjectOptions);
+      await updatePatch(opts, this._context, assignUpdate(doc, update, commands), origDoc);
+    });
+  });
+  schema.post(updateMethods, async function() {
+    const options = this.getOptions();
+    if (isHookIgnored(options)) 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) {
+      console.log("filter", filter);
+      current = await model.findOne(filter).sort("desc").lean().exec();
+    }
+    if (current) {
+      this._context.createdDocs = [current];
+      await createPatch(opts, this._context);
+    }
+  });
+};
+
+const remove = isMongooseLessThan7 ? "remove" : "deleteOne";
+const patchEventEmitter = em;
+const patchHistoryPlugin = function plugin(schema, opts) {
+  saveHooksInitialize(schema, opts);
+  updateHooksInitialize(schema, opts);
+  deleteHooksInitialize(schema, opts);
+  schema.post("insertMany", async function(docs) {
+    const context = {
+      op: "create",
+      modelName: opts.modelName ?? this.modelName,
+      collectionName: opts.collectionName ?? this.collection.collectionName,
+      createdDocs: docs
+    };
+    await createPatch(opts, context);
+  });
+  if (isMongooseLessThan8) {
+    schema.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() {
+      const original = this.toObject(toObjectOptions);
+      const model = this.constructor;
+      const context = {
+        op: "delete",
+        modelName: opts.modelName ?? model.modelName,
+        collectionName: opts.collectionName ?? model.collection.collectionName,
+        deletedDocs: [original]
+      };
+      await deletePatch(opts, context);
+    });
+  }
+};
+
+exports.patchEventEmitter = patchEventEmitter;
+exports.patchHistoryPlugin = patchHistoryPlugin;
+exports.setPatchHistoryTTL = setPatchHistoryTTL;

package/dist/index.d.cts

@@ -0,0 +1,75 @@
+import { HydratedDocument, Types, Query, Schema } from 'mongoose';
+import { Operation } from 'fast-json-patch';
+import ms from 'ms';
+
+interface History {
+    op: string;
+    modelName: string;
+    collectionName: string;
+    collectionId: Types.ObjectId;
+    version: number;
+    doc?: object;
+    user?: object;
+    reason?: string;
+    metadata?: object;
+    patch?: Operation[];
+}
+interface PatchEvent<T> {
+    oldDoc?: HydratedDocument<T>;
+    doc?: HydratedDocument<T>;
+    patch?: Operation[];
+}
+interface PatchContext<T> {
+    op: string;
+    modelName: string;
+    collectionName: string;
+    isNew?: boolean;
+    createdDocs?: HydratedDocument<T>[];
+    deletedDocs?: HydratedDocument<T>[];
+    ignoreEvent?: boolean;
+    ignorePatchHistory?: boolean;
+}
+type HookContext<T> = Query<T, T> & {
+    op: string;
+    _context: PatchContext<T>;
+};
+type User = Record<string, unknown>;
+type Metadata = Record<string, unknown>;
+interface PluginOptions<T> {
+    modelName?: string;
+    collectionName?: string;
+    eventUpdated?: string;
+    eventCreated?: string;
+    eventDeleted?: string;
+    getUser?: () => Promise<User> | User;
+    getReason?: () => Promise<string> | string;
+    getMetadata?: () => Promise<Metadata> | Metadata;
+    omit?: string[];
+    patchHistoryDisabled?: boolean;
+    preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>;
+}
+
+declare const setPatchHistoryTTL: (ttl: number | ms.StringValue) => Promise<void>;
+
+declare const patchEventEmitter: {
+    [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+    addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    on<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    once<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    off<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    removeAllListeners(eventName?: string | symbol | undefined): any;
+    setMaxListeners(n: number): any;
+    getMaxListeners(): number;
+    listeners<K>(eventName: string | symbol): Function[];
+    rawListeners<K>(eventName: string | symbol): Function[];
+    emit<K>(eventName: string | symbol, ...args: any[]): boolean;
+    listenerCount<K>(eventName: string | symbol, listener?: Function | undefined): number;
+    prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    eventNames(): (string | symbol)[];
+};
+
+declare const patchHistoryPlugin: <T>(schema: Schema<T>, opts: PluginOptions<T>) => void;
+
+export { type History, type HookContext, type Metadata, type PatchContext, type PatchEvent, type PluginOptions, type User, patchEventEmitter, patchHistoryPlugin, setPatchHistoryTTL };

package/dist/index.d.mts

@@ -0,0 +1,75 @@
+import { HydratedDocument, Types, Query, Schema } from 'mongoose';
+import { Operation } from 'fast-json-patch';
+import ms from 'ms';
+
+interface History {
+    op: string;
+    modelName: string;
+    collectionName: string;
+    collectionId: Types.ObjectId;
+    version: number;
+    doc?: object;
+    user?: object;
+    reason?: string;
+    metadata?: object;
+    patch?: Operation[];
+}
+interface PatchEvent<T> {
+    oldDoc?: HydratedDocument<T>;
+    doc?: HydratedDocument<T>;
+    patch?: Operation[];
+}
+interface PatchContext<T> {
+    op: string;
+    modelName: string;
+    collectionName: string;
+    isNew?: boolean;
+    createdDocs?: HydratedDocument<T>[];
+    deletedDocs?: HydratedDocument<T>[];
+    ignoreEvent?: boolean;
+    ignorePatchHistory?: boolean;
+}
+type HookContext<T> = Query<T, T> & {
+    op: string;
+    _context: PatchContext<T>;
+};
+type User = Record<string, unknown>;
+type Metadata = Record<string, unknown>;
+interface PluginOptions<T> {
+    modelName?: string;
+    collectionName?: string;
+    eventUpdated?: string;
+    eventCreated?: string;
+    eventDeleted?: string;
+    getUser?: () => Promise<User> | User;
+    getReason?: () => Promise<string> | string;
+    getMetadata?: () => Promise<Metadata> | Metadata;
+    omit?: string[];
+    patchHistoryDisabled?: boolean;
+    preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>;
+}
+
+declare const setPatchHistoryTTL: (ttl: number | ms.StringValue) => Promise<void>;
+
+declare const patchEventEmitter: {
+    [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+    addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    on<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    once<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    off<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    removeAllListeners(eventName?: string | symbol | undefined): any;
+    setMaxListeners(n: number): any;
+    getMaxListeners(): number;
+    listeners<K>(eventName: string | symbol): Function[];
+    rawListeners<K>(eventName: string | symbol): Function[];
+    emit<K>(eventName: string | symbol, ...args: any[]): boolean;
+    listenerCount<K>(eventName: string | symbol, listener?: Function | undefined): number;
+    prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    eventNames(): (string | symbol)[];
+};
+
+declare const patchHistoryPlugin: <T>(schema: Schema<T>, opts: PluginOptions<T>) => void;
+
+export { type History, type HookContext, type Metadata, type PatchContext, type PatchEvent, type PluginOptions, type User, patchEventEmitter, patchHistoryPlugin, setPatchHistoryTTL };