ts-patch-mongoose 1.1.3 → 1.1.5

package/src/plugin.ts

@@ -1,113 +1,44 @@
 import _ from 'lodash'
-import omit from 'omit-deep'
-import jsonpatch from 'fast-json-patch'
 import { assign } from 'power-assign'
 
-import type { CallbackError, HydratedDocument, Model, MongooseError, Schema, Types } from 'mongoose'
+import type { HydratedDocument, Model, MongooseQueryMiddleware, Schema, ToObjectOptions } from 'mongoose'
 
 import type IPluginOptions from './interfaces/IPluginOptions'
 import type IContext from './interfaces/IContext'
 import type IHookContext from './interfaces/IHookContext'
 
+import { createPatch, updatePatch, deletePatch } from './patch'
 import em from './em'
-import History from './models/History'
 
 const options = {
   document: false,
   query: true
 }
 
-function getObjects<T> (opts: IPluginOptions<T>, current: HydratedDocument<T>, original: HydratedDocument<T>): { currentObject: Partial<T>, originalObject: Partial<T> } {
-  let currentObject = JSON.parse(JSON.stringify(current)) as Partial<T>
-  let originalObject = JSON.parse(JSON.stringify(original)) as Partial<T>
-
-  if (opts.omit) {
-    currentObject = omit(currentObject, opts.omit)
-    originalObject = omit(originalObject, opts.omit)
-  }
-
-  return { currentObject, originalObject }
-}
-
-async function updatePatch<T> (opts: IPluginOptions<T>, context: IContext<T>, current: HydratedDocument<T>, original: HydratedDocument<T>): Promise<void> {
-  const { currentObject, originalObject } = getObjects(opts, current, original)
-
-  if (_.isEmpty(originalObject) || _.isEmpty(currentObject)) return
-
-  const patch = jsonpatch.compare(originalObject, currentObject, true)
-
-  if (_.isEmpty(patch)) return
-
-  if (opts.eventUpdated) {
-    em.emit(opts.eventUpdated, { oldDoc: original, doc: current, patch })
-  }
-
-  if (opts.patchHistoryDisabled) return
-
-  let version = 0
-
-  const lastHistory = await History.findOne({ collectionId: original._id as Types.ObjectId }).sort('-version').exec()
-
-  if (lastHistory && lastHistory.version >= 0) {
-    version = lastHistory.version + 1
-  }
-
-  await History.create({
-    op: context.op,
-    modelName: context.modelName,
-    collectionName: context.collectionName,
-    collectionId: original._id as Types.ObjectId,
-    patch,
-    version
-  })
+const toObjectOptions: ToObjectOptions = {
+  depopulate: true,
+  virtuals: false
 }
 
-async function bulkPatch<T> (opts: IPluginOptions<T>, context: IContext<T>, eventKey: 'eventCreated' | 'eventDeleted', docsKey: 'createdDocs' | 'deletedDocs'): Promise<void> {
-  const event = opts[eventKey]
-  const docs = context[docsKey]
-  const key = eventKey === 'eventCreated' ? 'doc' : 'oldDoc'
-
-  if (_.isEmpty(docs) || (!event && opts.patchHistoryDisabled)) return
-
-  const chunks = _.chunk(docs, 1000)
-  for await (const chunk of chunks) {
-    const bulk = []
-    for (const doc of chunk) {
-      if (event) em.emit(event, { [key]: doc })
-
-      if (!opts.patchHistoryDisabled) {
-        bulk.push({
-          insertOne: {
-            document: {
-              op: context.op,
-              modelName: context.modelName,
-              collectionName: context.collectionName,
-              collectionId: doc._id as Types.ObjectId,
-              doc,
-              version: 0
-            }
-          }
-        })
-      }
-    }
-
-    if (!opts.patchHistoryDisabled) {
-      await History
-        .bulkWrite(bulk, { ordered: false })
-        .catch((err: MongooseError) => {
-          console.error(err)
-        })
-    }
-  }
-}
-
-async function createPatch<T> (opts: IPluginOptions<T>, context: IContext<T>): Promise<void> {
-  await bulkPatch(opts, context, 'eventCreated', 'createdDocs')
-}
-
-async function deletePatch<T> (opts: IPluginOptions<T>, context: IContext<T>): Promise<void> {
-  await bulkPatch(opts, context, 'eventDeleted', 'deletedDocs')
-}
+const updateMethods = [
+  'update',
+  'updateOne',
+  'replaceOne',
+  'updateMany',
+  'findOneAndUpdate',
+  'findOneAndReplace',
+  'findByIdAndUpdate'
+]
+
+const deleteMethods = [
+  'remove',
+  'findOneAndDelete',
+  'findOneAndRemove',
+  'findByIdAndDelete',
+  'findByIdAndRemove',
+  'deleteOne',
+  'deleteMany'
+]
 
 /**
  * @description Patch patch event emitter
@@ -122,7 +53,7 @@ export const patchEventEmitter = em
  */
 export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: IPluginOptions<T>): void {
   schema.pre('save', async function (next) {
-    const current = this.toObject({ depopulate: true }) as HydratedDocument<T>
+    const current = this.toObject(toObjectOptions) as HydratedDocument<T>
     const model = this.constructor as Model<T>
 
     const context: IContext<T> = {
@@ -132,19 +63,16 @@ export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: I
       createdDocs: [current]
     }
 
-    try {
-      if (this.isNew) {
-        await createPatch(opts, context)
-      } else {
-        const original = await model.findById(current._id).exec()
-        if (original) {
-          await updatePatch(opts, context, current, original)
-        }
+    if (this.isNew) {
+      await createPatch(opts, context)
+    } else {
+      const original = await model.findById(current._id).exec()
+      if (original) {
+        await updatePatch(opts, context, current, original)
       }
-      next()
-    } catch (error) {
-      next(error as CallbackError)
     }
+
+    next()
   })
 
   schema.post('insertMany', async function (docs) {
@@ -158,7 +86,7 @@ export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: I
     await createPatch(opts, context)
   })
 
-  schema.pre(['update', 'updateOne', 'updateMany', 'findOneAndUpdate', 'findOneAndReplace'], async function (this: IHookContext<T>, next) {
+  schema.pre(updateMethods as MongooseQueryMiddleware[], async function (this: IHookContext<T>, next) {
     const filter = this.getFilter()
     const update = this.getUpdate() as Record<string, Partial<T>> | null
     const options = this.getOptions()
@@ -173,54 +101,50 @@ export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: I
       isNew: options.upsert && count === 0
     }
 
-    try {
-      const keys = _.keys(update).filter((key) => key.startsWith('$'))
-      if (update && !_.isEmpty(keys)) {
-        _.forEach(keys, (key) => {
-          commands.push({ [key]: update[key] })
-          // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-          delete update[key]
-        })
-      }
-      const cursor = this.model.find<HydratedDocument<T>>(filter).cursor()
-      await cursor.eachAsync(async (doc) => {
-        let current = doc.toObject({ depopulate: true }) as HydratedDocument<T>
-        const original = doc.toObject({ depopulate: true }) as HydratedDocument<T>
-        current = assign(current, update)
-        _.forEach(commands, (command) => {
-          try {
-            current = assign(current, command)
-          } catch (error) {
-            // we catch assign keys that are not implemented
-          }
-        })
-        await updatePatch(opts, this._context, current, original)
+    const keys = _.keys(update).filter((key) => key.startsWith('$'))
+    if (update && !_.isEmpty(keys)) {
+      _.forEach(keys, (key) => {
+        commands.push({ [key]: update[key] })
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete update[key]
       })
-      next()
-    } catch (error) {
-      next(error as CallbackError)
     }
+
+    const cursor = this.model.find<HydratedDocument<T>>(filter).cursor()
+    await cursor.eachAsync(async (doc) => {
+      let current = doc.toObject(toObjectOptions) as HydratedDocument<T>
+      const original = doc.toObject(toObjectOptions) as HydratedDocument<T>
+
+      current = assign(current, update)
+      _.forEach(commands, (command) => {
+        try {
+          current = assign(current, command)
+        } catch (error) {
+          // we catch assign keys that are not implemented
+        }
+      })
+
+      await updatePatch(opts, this._context, current, original)
+    })
+
+    next()
   })
 
-  schema.post(['update', 'updateOne', 'updateMany', 'findOneAndUpdate'], async function (this: IHookContext<T>) {
+  schema.post(updateMethods as MongooseQueryMiddleware[], async function (this: IHookContext<T>) {
     const update = this.getUpdate()
+    if (!update || !this._context.isNew) return
+
+    const found = await this.model.findOne<HydratedDocument<T>>(update).exec()
+    if (found) {
+      const current = found.toObject(toObjectOptions) as HydratedDocument<T>
+      this._context.createdDocs = [current]
 
-    if (update && this._context.isNew) {
-      const cursor = this.model.findOne<HydratedDocument<T>>(update).cursor()
-      await cursor.eachAsync((doc) => {
-        const current = doc.toObject({ depopulate: true }) as HydratedDocument<T>
-        if (this._context.createdDocs) {
-          this._context.createdDocs.push(current)
-        } else {
-          this._context.createdDocs = [current]
-        }
-      })
       await createPatch(opts, this._context)
     }
   })
 
-  schema.pre('remove', async function (this: HydratedDocument<T>, next) {
-    const original = this.toObject({ depopulate: true })
+  schema.post('remove', async function (this: HydratedDocument<T>) {
+    const original = this.toObject(toObjectOptions)
     const model = this.constructor as Model<T>
 
     const context: IContext<T> = {
@@ -229,18 +153,14 @@ export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: I
       collectionName: opts.collectionName ?? model.collection.collectionName
     }
 
-    try {
-      if (opts.eventDeleted) {
-        em.emit(opts.eventDeleted, { oldDoc: original })
-      }
-      await deletePatch(opts, context)
-      next()
-    } catch (error) {
-      next(error as CallbackError)
+    if (opts.eventDeleted) {
+      em.emit(opts.eventDeleted, { oldDoc: original })
     }
+
+    await deletePatch(opts, context)
   })
 
-  schema.pre(['remove', 'findOneAndDelete', 'findOneAndRemove', 'deleteOne', 'deleteMany'], options, async function (this: IHookContext<T>, next) {
+  schema.pre(deleteMethods as MongooseQueryMiddleware[], options, async function (this: IHookContext<T>, next) {
     const filter = this.getFilter()
     const options = this.getOptions()
     const ignore = options.__ignore as boolean
@@ -265,14 +185,14 @@ export const patchHistoryPlugin = function plugin<T> (schema: Schema<T>, opts: I
       }
     }
 
-    if (opts.preDeleteManyCallback && _.isArray(this._context.deletedDocs) && !_.isEmpty(this._context.deletedDocs)) {
-      await opts.preDeleteManyCallback(this._context.deletedDocs)
+    if (opts.preDeleteCallback && _.isArray(this._context.deletedDocs) && !_.isEmpty(this._context.deletedDocs)) {
+      await opts.preDeleteCallback(this._context.deletedDocs)
     }
 
     next()
   })
 
-  schema.post(['remove', 'findOneAndDelete', 'findOneAndRemove', 'deleteOne', 'deleteMany'], options, async function (this: IHookContext<T>) {
+  schema.post(deleteMethods as MongooseQueryMiddleware[], options, async function (this: IHookContext<T>) {
     await deletePatch(opts, this._context)
   })
 }

package/tests/em.test.ts

@@ -1,4 +1,4 @@
-import em from '../src/em'
+import { patchEventEmitter } from '../src/plugin'
 
 describe('em', () => {
   it('should subscribe and count', async () => {
@@ -6,11 +6,11 @@ describe('em', () => {
     const fn = () => {
       count++
     }
-    em.on('test', fn)
-    em.emit('test')
+    patchEventEmitter.on('test', fn)
+    patchEventEmitter.emit('test')
     expect(count).toBe(1)
-    em.off('test', fn)
-    em.emit('test')
+    patchEventEmitter.off('test', fn)
+    patchEventEmitter.emit('test')
     expect(count).toBe(1)
   })
 })

package/tests/patch.test.ts

@@ -0,0 +1,141 @@
+import mongoose, { model } from 'mongoose'
+
+import { getObjects, bulkPatch, updatePatch } from '../src/patch'
+import { patchHistoryPlugin } from '../src/plugin'
+
+import UserSchema from './schemas/UserSchema'
+
+import { USER_DELETED } from './constants/events'
+
+import type { HydratedDocument } from 'mongoose'
+import type IPluginOptions from '../src/interfaces/IPluginOptions'
+import type IUser from './interfaces/IUser'
+import type IContext from '../src/interfaces/IContext'
+
+import em from '../src/em'
+
+jest.mock('../src/em', () => {
+  return {
+    emit: jest.fn()
+  }
+})
+
+describe('patch tests', () => {
+  const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
+
+  UserSchema.plugin(patchHistoryPlugin, {
+    eventDeleted: USER_DELETED,
+    patchHistoryDisabled: true
+  })
+
+  const User = model('User', UserSchema)
+
+  beforeAll(async () => {
+    await mongoose.connect(uri)
+  })
+
+  afterAll(async () => {
+    await mongoose.connection.close()
+  })
+
+  beforeEach(async () => {
+    await mongoose.connection.collection('tests').deleteMany({})
+    await mongoose.connection.collection('patches').deleteMany({})
+  })
+
+  describe('getObjects', () => {
+    it('should omit properties from currentObject and originalObject based on the opts', async () => {
+      const original = await User.create({ name: 'John', role: 'user' })
+      const current = await User.create({ name: 'John', role: 'admin' })
+
+      const pluginOptions = {
+        omit: ['createdAt']
+      }
+
+      const { currentObject, originalObject } = getObjects(pluginOptions, current, original)
+
+      expect(currentObject.name).toBe('John')
+      expect(currentObject.role).toBe('admin')
+      expect(currentObject.createdAt).toBeUndefined()
+
+      expect(originalObject.name).toBe('John')
+      expect(originalObject.role).toBe('user')
+      expect(originalObject.createdAt).toBeUndefined()
+    })
+
+    it('should not omit properties from currentObject and originalObject if opts is empty', async () => {
+      const original = await User.create({ name: 'John', role: 'user' })
+      const current = await User.create({ name: 'John', role: 'admin' })
+
+      const { currentObject, originalObject } = getObjects({}, current, original)
+
+      expect(currentObject.name).toBe('John')
+      expect(currentObject.role).toBe('admin')
+      expect(currentObject.createdAt).toBeDefined()
+
+      expect(originalObject.name).toBe('John')
+      expect(originalObject.role).toBe('user')
+      expect(originalObject.createdAt).toBeDefined()
+    })
+  })
+
+  describe('bulkPatch', () => {
+    it('should emit eventDeleted if opts.patchHistoryDisabled is false', async () => {
+      const doc = new User({ name: 'John', role: 'user' })
+
+      const pluginOptions: IPluginOptions<IUser> = {
+        eventDeleted: USER_DELETED,
+        patchHistoryDisabled: false
+      }
+
+      const context: IContext<IUser> = {
+        op: 'deleteOne',
+        modelName: 'User',
+        collectionName: 'users',
+        deletedDocs: [doc]
+      }
+
+      await bulkPatch(pluginOptions, context, 'eventDeleted', 'deletedDocs')
+      expect(em.emit).toHaveBeenCalled()
+    })
+
+    it('should emit eventDeleted if opts.patchHistoryDisabled is true', async () => {
+      const doc = new User({ name: 'John', role: 'user' })
+
+      const pluginOptions: IPluginOptions<IUser> = {
+        eventDeleted: USER_DELETED,
+        patchHistoryDisabled: true
+      }
+
+      const context: IContext<IUser> = {
+        op: 'deleteOne',
+        modelName: 'User',
+        collectionName: 'users',
+        deletedDocs: [doc]
+      }
+
+      await bulkPatch(pluginOptions, context, 'eventDeleted', 'deletedDocs')
+      expect(em.emit).toHaveBeenCalled()
+    })
+  })
+
+  describe('updatePatch', () => {
+    it('should return if one object is empty', async () => {
+      const current = await User.create({ name: 'John', role: 'user' })
+
+      const pluginOptions: IPluginOptions<IUser> = {
+        eventDeleted: USER_DELETED,
+        patchHistoryDisabled: true
+      }
+
+      const context: IContext<IUser> = {
+        op: 'updateOne',
+        modelName: 'User',
+        collectionName: 'users'
+      }
+
+      await updatePatch(pluginOptions, context, current, {} as HydratedDocument<IUser>)
+      expect(em.emit).not.toHaveBeenCalled()
+    })
+  })
+})

package/tests/plugin-callback.test.ts

@@ -0,0 +1,50 @@
+import mongoose, { model } from 'mongoose'
+
+import UserSchema from './schemas/UserSchema'
+import { patchHistoryPlugin } from '../src/plugin'
+
+import { USER_CREATED } from './constants/events'
+
+const preDeleteCallbackMock = jest.fn()
+
+describe('plugin - event created & patch history disabled', () => {
+  const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
+
+  UserSchema.plugin(patchHistoryPlugin, {
+    eventCreated: USER_CREATED,
+    patchHistoryDisabled: true,
+    preDeleteCallback: preDeleteCallbackMock
+  })
+
+  const User = model('User', UserSchema)
+
+  beforeAll(async () => {
+    await mongoose.connect(uri)
+  })
+
+  afterAll(async () => {
+    await mongoose.connection.close()
+  })
+
+  beforeEach(async () => {
+    await mongoose.connection.collection('users').deleteMany({})
+    await mongoose.connection.collection('history').deleteMany({})
+  })
+
+  it('should deleteMany and execute preDeleteCallback', async () => {
+    await User.create([
+      { name: 'John', role: 'user' },
+      { name: 'Jane', role: 'user' },
+      { name: 'Jack', role: 'user' }
+    ])
+
+    const users = await User.find({})
+    expect(users).toHaveLength(3)
+
+    const [john, jane, jack] = users
+
+    await User.deleteMany({ role: 'user' })
+    expect(preDeleteCallbackMock).toHaveBeenCalledTimes(1)
+    expect(preDeleteCallbackMock).toHaveBeenCalledWith([john, jane, jack])
+  })
+})