ts-patch-mongoose 1.0.1

package/src/modules/power-assign.d.ts

@@ -0,0 +1,3 @@
+declare module 'power-assign' {
+  export function assign<T, U>(object1: T, object2: U): T & U
+}

package/src/plugin.ts

@@ -0,0 +1,267 @@
+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 IPluginOptions from './interfaces/IPluginOptions'
+import type IContext from './interfaces/IContext'
+import type IHookContext from './interfaces/IHookContext'
+
+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 bulkPatch<T> (opts: IPluginOptions<T>, context: IContext<T>): Promise<void> {
+  const chunks = _.chunk(context.deletedDocs, 1000)
+  for await (const chunk of chunks) {
+    const bulk = []
+    for (const oldDoc of chunk) {
+      if (opts.eventDeleted) {
+        em.emit(opts.eventDeleted, { oldDoc })
+      }
+      if (!opts.patchHistoryDisabled) {
+        bulk.push({
+          insertOne: {
+            document: {
+              op: context.op,
+              modelName: context.modelName,
+              collectionName: context.collectionName,
+              collectionId: oldDoc._id as Types.ObjectId,
+              doc: oldDoc,
+              version: 0
+            }
+          }
+        })
+      }
+    }
+
+    if (opts.patchHistoryDisabled) continue
+    await History.bulkWrite(bulk, { ordered: false }).catch((err: MongooseError) => {
+      console.error(err)
+    })
+  }
+}
+
+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
+  })
+}
+
+async function createPatch<T> (opts: IPluginOptions<T>, context: IContext<T>, current: HydratedDocument<T>): Promise<void> {
+  if (opts.patchHistoryDisabled) return
+
+  await History.create({
+    op: context.op,
+    modelName: context.modelName,
+    collectionName: context.collectionName,
+    collectionId: current._id as Types.ObjectId,
+    doc: current
+  })
+}
+
+/**
+ * @description Patch patch event emitter
+ */
+export const patchEventEmitter = em
+
+/**
+ * @description Patch history plugin
+ * @param {Schema} schema
+ * @param {IPluginOptions} opts
+ * @returns {void}
+ */
+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 model = this.constructor as Model<T>
+
+    const context: IContext<T> = {
+      op: this.isNew ? 'create' : 'update',
+      modelName: opts.modelName ?? model.modelName,
+      collectionName: opts.collectionName ?? model.collection.collectionName
+    }
+
+    try {
+      if (this.isNew) {
+        if (opts.eventCreated) {
+          em.emit(opts.eventCreated, { doc: current })
+        }
+        await createPatch(opts, context, current)
+      } else {
+        const original = await model.findById(current._id).exec()
+        if (original) {
+          await updatePatch(opts, context, current, original)
+        }
+      }
+      next()
+    } catch (error) {
+      next(error as CallbackError)
+    }
+  })
+
+  schema.pre(['findOneAndUpdate', 'update', 'updateOne', 'updateMany'], async function (this: IHookContext<T>, next) {
+    const filter = this.getFilter()
+    const update = this.getUpdate() as Record<string, Partial<T>> | null
+    const options = this.getOptions()
+
+    const count = await this.model.count(filter).exec()
+    const commands: Record<string, Partial<T>>[] = []
+
+    const context: IContext<T> = {
+      op: this.op,
+      modelName: opts.modelName ?? this.model.modelName,
+      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      isNew: options.upsert && count === 0
+    }
+
+    this._context = context
+
+    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(filter).cursor()
+      await cursor.eachAsync(async (doc: HydratedDocument<T>) => {
+        let current = 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, context, current, doc.toObject({ depopulate: true }) as HydratedDocument<T>)
+      })
+      next()
+    } catch (error) {
+      next(error as CallbackError)
+    }
+  })
+
+  schema.post(['findOneAndUpdate', 'update', 'updateOne', 'updateMany'], async function (this: IHookContext<T>) {
+    const update = this.getUpdate()
+
+    if (update && this._context.isNew) {
+      const cursor = this.model.findOne(update).cursor()
+      await cursor.eachAsync(async (current: HydratedDocument<T>) => {
+        if (opts.eventCreated) {
+          em.emit(opts.eventCreated, { doc: current })
+        }
+        await createPatch(opts, this._context, current)
+      })
+    }
+  })
+
+  schema.pre('updateMany', options, async function (this: IHookContext<T>, next) {
+    const filter = this.getFilter()
+    const options = this.getOptions()
+    const ignore = options.__ignore as boolean
+
+    const context: IContext<T> = {
+      op: this.op,
+      modelName: opts.modelName ?? this.model.modelName,
+      collectionName: opts.collectionName ?? this.model.collection.collectionName,
+      isNew: options.upsert
+    }
+
+    if (!ignore) {
+      const ids = await this.model.distinct<Types.ObjectId>('_id', filter).exec()
+      context.updatedIds = ids
+    }
+
+    this._context = context
+
+    next()
+  })
+
+  schema.post('updateMany', options, async function (this: IHookContext<T>) {
+    if (this._context.updatedIds?.length) return
+
+    const cursor = this.model.find({ _id: { $in: this._context.updatedIds } }).cursor()
+    await cursor.eachAsync((current: HydratedDocument<T>) => {
+      if (opts.eventUpdated) {
+        em.emit(opts.eventUpdated, { doc: current })
+      }
+    })
+  })
+
+  schema.pre(['remove', 'findOneAndDelete', 'findOneAndRemove', 'deleteOne', 'deleteMany'], options, async function (this: IHookContext<T>, next) {
+    const filter = this.getFilter()
+    const options = this.getOptions()
+    const ignore = options.__ignore as boolean
+
+    const context: IContext<T> = {
+      op: this.op,
+      modelName: opts.modelName ?? this.model.modelName,
+      collectionName: opts.collectionName ?? this.model.collection.collectionName
+    }
+
+    if (!ignore) {
+      context.deletedDocs = await this.model.find(filter).exec()
+      if (opts.preDeleteManyCallback) {
+        await opts.preDeleteManyCallback(context.deletedDocs)
+      }
+    }
+
+    this._context = context
+    next()
+  })
+
+  schema.post(['remove', 'findOneAndDelete', 'findOneAndRemove', 'deleteOne', 'deleteMany'], options, async function (this: IHookContext<T>) {
+    if (_.isEmpty(this._context.deletedDocs)) return
+
+    await bulkPatch(opts, this._context)
+  })
+}

package/tests/constants/events.ts

@@ -0,0 +1,3 @@
+export const USER_CREATED_EVENT = 'testCreated'
+export const USER_UPDATED_EVENT = 'testUpdated'
+export const USER_DELETED_EVENT = 'testDeleted'

package/tests/em.test.ts

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

package/tests/interfaces/IUser.ts

@@ -0,0 +1,8 @@
+interface IUser {
+  name: string
+  role: string
+  createdAt?: Date
+  updatedAt?: Date
+}
+
+export default IUser

package/tests/models/User.ts

@@ -0,0 +1,29 @@
+import { Schema, model } from 'mongoose'
+
+import type IUser from '../interfaces/IUser'
+
+import { patchHistoryPlugin } from '../../src/plugin'
+
+import { USER_CREATED_EVENT, USER_DELETED_EVENT, USER_UPDATED_EVENT } from '../constants/events'
+
+const UserSchema = new Schema<IUser>({
+  name: {
+    type: String,
+    required: true
+  },
+  role: {
+    type: String,
+    required: true
+  }
+}, { timestamps: true })
+
+UserSchema.plugin(patchHistoryPlugin, {
+  eventCreated: USER_CREATED_EVENT,
+  eventUpdated: USER_UPDATED_EVENT,
+  eventDeleted: USER_DELETED_EVENT,
+  omit: ['__v', 'role', 'createdAt', 'updatedAt']
+})
+
+const User = model('User', UserSchema)
+
+export default User

package/tests/mongose.test.ts

@@ -0,0 +1,28 @@
+import mongoose from 'mongoose'
+
+describe('mongoose', () => {
+  const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
+
+  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({})
+  })
+
+  it('should insert a doc into collection', async () => {
+    const users = mongoose.connection.db.collection('users')
+
+    const mockUser = { name: 'John' }
+    const user = await users.insertOne(mockUser)
+
+    const insertedUser = await users.findOne({ _id: user.insertedId })
+    expect(insertedUser).toEqual(mockUser)
+  })
+})

package/tests/plugin.test.ts

@@ -0,0 +1,243 @@
+import mongoose from 'mongoose'
+
+import User from './models/User'
+import History from '../src/models/History'
+
+import em from '../src/em'
+
+import { USER_CREATED_EVENT, USER_UPDATED_EVENT, USER_DELETED_EVENT } from './constants/events'
+
+jest.mock('../src/em', () => {
+  return { emit: jest.fn() }
+})
+
+describe('plugin', () => {
+  const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
+
+  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 createHistory', async () => {
+    const user = await User.create({ name: 'John', role: 'user' })
+    expect(user.name).toBe('John')
+
+    user.name = 'Alice'
+    await user.save()
+
+    user.name = 'Bob'
+    await user.save()
+
+    const history = await History.find({})
+    expect(history).toHaveLength(3)
+
+    const [first, second, third] = history
+
+    expect(first.op).toBe('create')
+    expect(first.patch).toHaveLength(0)
+    expect(first.doc.name).toBe('John')
+    expect(first.doc.role).toBe('user')
+    expect(first.version).toBe(0)
+
+    expect(second.op).toBe('update')
+    expect(second.patch).toHaveLength(2)
+    expect(second.patch[1].value).toBe('Alice')
+    expect(second.version).toBe(1)
+
+    expect(third.op).toBe('update')
+    expect(third.patch).toHaveLength(2)
+    expect(third.patch[1].value).toBe('Bob')
+    expect(third.version).toBe(2)
+
+    await User.deleteMany({ role: 'user' }).exec()
+
+    expect(em.emit).toHaveBeenCalledTimes(4)
+    expect(em.emit).toHaveBeenCalledWith(USER_CREATED_EVENT, { doc: first.doc })
+    expect(em.emit).toHaveBeenCalledWith(USER_UPDATED_EVENT, {
+      oldDoc: expect.objectContaining({ _id: user._id, name: 'John', role: 'user' }),
+      doc: expect.objectContaining({ _id: user._id, name: 'Alice', role: 'user' }),
+      patch: second.patch
+    })
+    expect(em.emit).toHaveBeenCalledWith(USER_UPDATED_EVENT, {
+      oldDoc: expect.objectContaining({ _id: user._id, name: 'Alice', role: 'user' }),
+      doc: expect.objectContaining({ _id: user._id, name: 'Bob', role: 'user' }),
+      patch: third.patch
+    })
+    expect(em.emit).toHaveBeenCalledWith(USER_DELETED_EVENT, {
+      oldDoc: expect.objectContaining({ _id: user._id, name: 'Bob', role: 'user' })
+    })
+  })
+
+  it('should omit update of role', async () => {
+    const user = await User.create({ name: 'John', role: 'user' })
+    expect(user.name).toBe('John')
+
+    user.role = 'manager'
+    await user.save()
+
+    const history = await History.find({})
+    expect(history).toHaveLength(1)
+
+    const [first] = history
+
+    expect(first.op).toBe('create')
+    expect(first.patch).toHaveLength(0)
+    expect(first.doc.name).toBe('John')
+    expect(first.doc.role).toBe('user')
+    expect(first.version).toBe(0)
+
+    expect(user.role).toBe('manager')
+  })
+
+  it('should updateOne', async () => {
+    const user = await User.create({ name: 'John', role: 'user' })
+    expect(user.name).toBe('John')
+
+    await User.updateOne({ _id: user._id }, { name: 'Alice' }).exec()
+
+    const history = await History.find({})
+    expect(history).toHaveLength(2)
+
+    const [first, second] = history
+
+    expect(first.op).toBe('create')
+    expect(first.patch).toHaveLength(0)
+    expect(first.doc.name).toBe('John')
+    expect(first.doc.role).toBe('user')
+    expect(first.version).toBe(0)
+
+    expect(second.op).toBe('updateOne')
+    expect(second.patch).toHaveLength(2)
+    expect(second.patch[1].value).toBe('Alice')
+    expect(second.version).toBe(1)
+  })
+
+  it('should findOneAndUpdate', async () => {
+    const user = await User.create({ name: 'John', role: 'user' })
+    expect(user.name).toBe('John')
+
+    await User.findOneAndUpdate({ _id: user._id }, { name: 'Alice' }).exec()
+
+    const history = await History.find({})
+    expect(history).toHaveLength(2)
+
+    const [first, second] = history
+
+    expect(first.op).toBe('create')
+    expect(second.patch).toHaveLength(2)
+    expect(first.doc.name).toBe('John')
+    expect(first.version).toBe(0)
+
+    expect(second.op).toBe('findOneAndUpdate')
+    expect(second.patch).toHaveLength(2)
+    expect(second.patch[1].value).toBe('Alice')
+    expect(second.version).toBe(1)
+  })
+
+  it('should update deprecated', async () => {
+    const user = await User.create({ name: 'John', role: 'user' })
+    expect(user.name).toBe('John')
+
+    await User.update({ _id: user._id }, { $set: { name: 'Alice' } }).exec()
+
+    const history = await History.find({})
+    expect(history).toHaveLength(2)
+
+    const [first, second] = history
+
+    expect(first.op).toBe('create')
+    expect(second.patch).toHaveLength(2)
+    expect(first.doc.name).toBe('John')
+    expect(first.version).toBe(0)
+
+    expect(second.op).toBe('update')
+    expect(second.patch).toHaveLength(2)
+    expect(second.patch[1].value).toBe('Alice')
+    expect(second.version).toBe(1)
+  })
+
+  it('should updated deprecated with multi flag', async () => {
+    const john = await User.create({ name: 'John', role: 'user' })
+    expect(john.name).toBe('John')
+    const alice = await User.create({ name: 'Alice', role: 'user' })
+    expect(alice.name).toBe('Alice')
+
+    await User.update({ role: 'user' }, { $set: { name: 'Bob' } }, { multi: true }).exec()
+
+    const history = await History.find({})
+    expect(history).toHaveLength(4)
+
+    const [first, second, third, fourth] = history
+
+    expect(first.op).toBe('create')
+    expect(second.patch).toHaveLength(0)
+    expect(first.doc.name).toBe('John')
+    expect(first.doc.role).toBe('user')
+    expect(first.version).toBe(0)
+
+    expect(second.op).toBe('create')
+    expect(second.patch).toHaveLength(0)
+    expect(second.doc.name).toBe('Alice')
+    expect(first.doc.role).toBe('user')
+    expect(second.version).toBe(0)
+
+    expect(third.op).toBe('update')
+    expect(third.patch).toHaveLength(2)
+    expect(third.patch[1].value).toBe('Bob')
+    expect(third.version).toBe(1)
+
+    expect(fourth.op).toBe('update')
+    expect(fourth.patch).toHaveLength(2)
+    expect(fourth.patch[1].value).toBe('Bob')
+    expect(fourth.version).toBe(1)
+  })
+
+  it('should create many', async () => {
+    await User.create([
+      { name: 'John', role: 'user' },
+      { name: 'Alice', role: 'user' }
+    ])
+
+    const history = await History.find({})
+    expect(history).toHaveLength(2)
+
+    const [first, second] = history
+
+    expect(first.op).toBe('create')
+    expect(first.patch).toHaveLength(0)
+    expect(first.doc.name).toBe('John')
+    expect(first.doc.role).toBe('user')
+    expect(first.version).toBe(0)
+
+    expect(second.op).toBe('create')
+    expect(second.patch).toHaveLength(0)
+    expect(second.doc.name).toBe('Alice')
+    expect(second.doc.role).toBe('user')
+    expect(second.version).toBe(0)
+  })
+
+  it('should findOneAndUpdate upsert', async () => {
+    await User.findOneAndUpdate({ name: 'John', role: 'user' }, { name: 'Bob', role: 'user' }, { upsert: true, runValidators: true }).exec()
+    const documents = await User.find({})
+    expect(documents).toHaveLength(1)
+
+    const history = await History.find({})
+    expect(history).toHaveLength(1)
+
+    const [first] = history
+
+    expect(first.op).toBe('findOneAndUpdate')
+    expect(first.patch).toHaveLength(0)
+    expect(first.doc.name).toBe('Bob')
+    expect(first.version).toBe(0)
+  })
+})

package/tests/utils/filesystem.ts

@@ -0,0 +1,13 @@
+import fs from 'fs'
+import path from 'path'
+
+export const clearDirectory = (dir: string) => {
+  if (!fs.existsSync(dir)) return
+  const files = fs.readdirSync(dir)
+  for (const file of files) {
+    const filePath = path.join(dir, file)
+    if (fs.statSync(filePath).isFile()) {
+      fs.unlinkSync(filePath)
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "target": "es2021",
+    "lib": [
+      "es2021"
+    ],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "strict": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true, 
+    "strictPropertyInitialization": true,    
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitUseStrict": false,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "importHelpers": true,
+    "removeComments": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "dist",
+    "tools",
+    "node_modules"
+  ],
+  "ts-node": {
+    "swc": true
+  }
+}