ts-patch-mongoose 2.7.1 → 2.8.1

package/dist/index.mjs

@@ -0,0 +1,391 @@
+import _ from 'lodash';
+import EventEmitter from 'node:events';
+import ms from 'ms';
+import mongoose, { Schema, model } from 'mongoose';
+import jsonpatch from 'fast-json-patch';
+import omit from 'omit-deep';
+import { satisfies } from 'semver';
+import { assign } from 'power-assign';
+
+class PatchEventEmitter extends EventEmitter {
+}
+const em = new PatchEventEmitter();
+
+const HistorySchema = new Schema(
+  {
+    op: {
+      type: String,
+      required: true
+    },
+    modelName: {
+      type: String,
+      required: true
+    },
+    collectionName: {
+      type: String,
+      required: true
+    },
+    collectionId: {
+      type: 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 = 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 = satisfies(mongoose.version, "<8");
+const isMongooseLessThan7 = satisfies(mongoose.version, "<7");
+const isMongoose6 = 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 = assign(document.toObject(toObjectOptions), update);
+  _.forEach(commands, (command) => {
+    try {
+      updated = 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);
+    });
+  }
+};
+
+export { patchEventEmitter, patchHistoryPlugin, setPatchHistoryTTL };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ts-patch-mongoose",
-  "version": "2.7.1",
+  "version": "2.8.1",
   "description": "Patch history & events for mongoose models",
-  "author": "Alex Eagle",
+  "author": "ilovepixelart",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -25,7 +25,6 @@
     "nosql",
     "ts",
     "typescript",
-    "swc",
     "patch",
     "history",
     "event",
@@ -43,60 +42,65 @@
     "dist",
     "src",
     "tests",
-    ".swcrc",
     "tsconfig.json",
     "vite.config.mts",
     "biome.json"
   ],
+  "type": "module",
   "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/esm/types/plugin.d.ts",
-        "default": "./dist/esm/plugin.js"
-      },
-      "require": {
-        "types": "./dist/cjs/types/plugin.d.ts",
-        "default": "./dist/cjs/plugin.js"
-      }
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     }
   },
-  "main": "dist/cjs/plugin.js",
-  "module": "dist/esm/plugin.js",
-  "types": "dist/cjs/types/plugin.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
   "scripts": {
+    "prepare": "simple-git-hooks",
     "biome": "npx @biomejs/biome check",
     "biome:fix": "npx @biomejs/biome check --write .",
     "test": "vitest run --coverage",
     "test:open": "vitest run --coverage && open-cli coverage/lcov-report/index.html",
-    "clean": "rm -rf ./dist",
-    "build": "npm run clean && npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -p config/tsconfig.cjs.json",
-    "build:esm": "tsc -p config/tsconfig.esm.json && bash/esm.sh",
-    "release": "npm install && npm run biome && npm run build && np"
+    "type:check": "tsc --noEmit",
+    "build": "pkgroll --clean-dist",
+    "release": "npm install && npm run biome && npm run type:check && npm run build && np"
   },
   "dependencies": {
+    "@types/lodash": "4.17.16",
+    "@types/ms": "2.1.0",
+    "@types/semver": "7.5.8",
     "fast-json-patch": "3.1.1",
     "lodash": "4.17.21",
     "ms": "2.1.3",
     "omit-deep": "0.3.0",
     "power-assign": "0.2.10",
-    "semver": "7.6.3"
+    "semver": "7.7.1"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@types/lodash": "4.17.14",
-    "@types/ms": "2.1.0",
-    "@types/node": "22.10.7",
-    "@types/semver": "7.5.8",
-    "@vitest/coverage-v8": "3.0.2",
-    "merge": "2.1.1",
-    "mongodb-memory-server": "10.1.3",
-    "mongoose": "8.9.5",
+    "@types/node": "22.13.8",
+    "@vitest/coverage-v8": "3.0.7",
+    "mongodb-memory-server": "10.1.4",
+    "mongoose": "8.11.0",
     "open-cli": "8.0.0",
-    "typescript": "5.7.3",
-    "vitest": "3.0.2"
+    "pkgroll": "2.11.2",
+    "simple-git-hooks": "2.11.1",
+    "typescript": "5.8.2",
+    "vitest": "3.0.7"
   },
   "peerDependencies": {
     "mongoose": ">=6.6.0 < 9"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "npm run type:check",
+    "pre-push": "npm run biome:fix"
+  },
+  "overrides": {
+    "esbuild": "0.25.0"
   }
 }

package/src/helpers.ts

@@ -1,6 +1,6 @@
 import ms from 'ms'
 
-import History from './models/History'
+import { HistoryModel } from './model'
 
 import type { QueryOptions, ToObjectOptions } from 'mongoose'
 
@@ -16,12 +16,12 @@ export const toObjectOptions: ToObjectOptions = {
 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
   try {
-    const indexes = await History.collection.indexes()
+    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 History.collection.dropIndex(name)
+      await HistoryModel.collection.dropIndex(name)
       return
     }
 
@@ -29,7 +29,7 @@ export const setPatchHistoryTTL = async (ttl: number | ms.StringValue): Promise<
 
     // Drop the index if historyTTL is less than 1 second and index exists
     if (milliseconds < 1000 && existingIndex) {
-      await History.collection.dropIndex(name)
+      await HistoryModel.collection.dropIndex(name)
       return
     }
 
@@ -42,11 +42,11 @@ export const setPatchHistoryTTL = async (ttl: number | ms.StringValue): Promise<
 
     if (existingIndex) {
       // Drop the existing index if it exists and TTL is different
-      await History.collection.dropIndex(name)
+      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 History.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds, name })
+    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,16 +1,15 @@
-import { isArray, isEmpty } from 'lodash'
+import _ from 'lodash'
 
 import { isHookIgnored } from '../helpers'
 import { deletePatch } from '../patch'
 
 import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema } from 'mongoose'
-import type IHookContext from '../interfaces/IHookContext'
-import type IPluginOptions from '../interfaces/IPluginOptions'
+import type { HookContext, PluginOptions } from '../types'
 
 const deleteMethods = ['remove', 'findOneAndDelete', 'findOneAndRemove', 'findByIdAndDelete', 'findByIdAndRemove', 'deleteOne', 'deleteMany']
 
-export const deleteHooksInitialize = <T>(schema: Schema<T>, opts: IPluginOptions<T>): void => {
-  schema.pre(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: IHookContext<T>) {
+export const deleteHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
+  schema.pre(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: HookContext<T>) {
     const options = this.getOptions()
     if (isHookIgnored(options)) return
 
@@ -27,22 +26,22 @@ export const deleteHooksInitialize = <T>(schema: Schema<T>, opts: IPluginOptions
 
     if (['remove', 'deleteMany'].includes(this._context.op) && !options.single) {
       const docs = await model.find<T>(filter).lean().exec()
-      if (!isEmpty(docs)) {
+      if (!_.isEmpty(docs)) {
         this._context.deletedDocs = docs as HydratedDocument<T>[]
       }
     } else {
       const doc = await model.findOne<T>(filter).lean().exec()
-      if (!isEmpty(doc)) {
+      if (!_.isEmpty(doc)) {
         this._context.deletedDocs = [doc] as HydratedDocument<T>[]
       }
     }
 
-    if (opts.preDelete && isArray(this._context.deletedDocs) && !isEmpty(this._context.deletedDocs)) {
+    if (opts.preDelete && _.isArray(this._context.deletedDocs) && !_.isEmpty(this._context.deletedDocs)) {
       await opts.preDelete(this._context.deletedDocs)
     }
   })
 
-  schema.post(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: IHookContext<T>) {
+  schema.post(deleteMethods as MongooseQueryMiddleware[], { document: false, query: true }, async function (this: HookContext<T>) {
     const options = this.getOptions()
     if (isHookIgnored(options)) return
 

package/src/hooks/save-hooks.ts

@@ -2,17 +2,16 @@ import { toObjectOptions } from '../helpers'
 import { createPatch, updatePatch } from '../patch'
 
 import type { HydratedDocument, Model, Schema } from 'mongoose'
-import type IContext from '../interfaces/IContext'
-import type IPluginOptions from '../interfaces/IPluginOptions'
+import type { PatchContext, PluginOptions } from '../types'
 
-export const saveHooksInitialize = <T>(schema: Schema<T>, opts: IPluginOptions<T>): void => {
+export const saveHooksInitialize = <T>(schema: Schema<T>, opts: PluginOptions<T>): void => {
   schema.pre('save', async function () {
     if (this.constructor.name !== 'model') return
 
     const current = this.toObject(toObjectOptions) as HydratedDocument<T>
     const model = this.constructor as Model<T>
 
-    const context: IContext<T> = {
+    const context: PatchContext<T> = {
       op: this.isNew ? 'create' : 'update',
       modelName: opts.modelName ?? model.modelName,
       collectionName: opts.collectionName ?? model.collection.collectionName,