ts-patch-mongoose 1.1.3 → 1.1.5

package/tests/plugin-event-created.test.ts

@@ -1,4 +1,4 @@
-import mongoose, { model } from 'mongoose'
+import mongoose, { Types, model } from 'mongoose'
 
 import UserSchema from './schemas/UserSchema'
 import { patchHistoryPlugin } from '../src/plugin'
@@ -36,99 +36,248 @@ describe('plugin - event created & patch history disabled', () => {
     await mongoose.connection.collection('history').deleteMany({})
   })
 
-  it('should save and emit one create event', async () => {
-    const john = new User({ name: 'John', role: 'user' })
-    await john.save()
-
-    const history = await History.find({})
-    expect(history).toHaveLength(0)
-
-    expect(em.emit).toHaveBeenCalledTimes(1)
-    expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-      doc: expect.objectContaining({
-        _id: john._id,
-        name: john.name,
-        role: john.role,
-        createdAt: john.createdAt,
-        updatedAt: john.updatedAt
+  describe('normal cases', () => {
+    it('should save() and emit one create event', async () => {
+      const john = new User({ name: 'John', role: 'user' })
+      await john.save()
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: john._id,
+          name: john.name,
+          role: john.role,
+          createdAt: john.createdAt,
+          updatedAt: john.updatedAt
+        })
       })
     })
-  })
 
-  it('should create and emit one create event', async () => {
-    const user = await User.create({ name: 'John', role: 'user' })
+    it('should create() and emit one create event', async () => {
+      const user = await User.create({ name: 'John', role: 'user' })
 
-    const history = await History.find({})
-    expect(history).toHaveLength(0)
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
 
-    expect(em.emit).toHaveBeenCalledTimes(1)
-    expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-      doc: expect.objectContaining({
-        _id: user._id,
-        name: user.name,
-        role: user.role,
-        createdAt: user.createdAt,
-        updatedAt: user.updatedAt
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: user._id,
+          name: user.name,
+          role: user.role,
+          createdAt: user.createdAt,
+          updatedAt: user.updatedAt
+        })
       })
     })
-  })
 
-  it('should insertMany and emit one create event', async () => {
-    const [user] = await User.insertMany([{ name: 'John', role: 'user' }])
+    it('should insertMany() and emit three create events', async () => {
+      const users = await User.insertMany([
+        { name: 'John', role: 'user' },
+        { name: 'Alice', role: 'user' },
+        { name: 'Bob', role: 'user' }
+      ])
+
+      const [john, alice, bob] = users
 
-    const history = await History.find({})
-    expect(history).toHaveLength(0)
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
 
-    expect(em.emit).toHaveBeenCalledTimes(1)
-    expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
-      doc: expect.objectContaining({
-        _id: user._id,
-        name: user.name,
-        role: user.role,
-        createdAt: user.createdAt,
-        updatedAt: user.updatedAt
+      expect(em.emit).toHaveBeenCalledTimes(3)
+      expect(em.emit).toHaveBeenNthCalledWith(1, USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: john._id,
+          name: john.name,
+          role: john.role,
+          createdAt: john.createdAt,
+          updatedAt: john.updatedAt
+        })
+      })
+      expect(em.emit).toHaveBeenNthCalledWith(2, USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: alice._id,
+          name: alice.name,
+          role: alice.role,
+          createdAt: alice.createdAt,
+          updatedAt: alice.updatedAt
+        })
+      })
+      expect(em.emit).toHaveBeenNthCalledWith(3, USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: bob._id,
+          name: bob.name,
+          role: bob.role,
+          createdAt: bob.createdAt,
+          updatedAt: bob.updatedAt
+        })
       })
     })
   })
 
-  it('should insertMany and emit three create events', async () => {
-    const users = await User.insertMany([
-      { name: 'John', role: 'user' },
-      { name: 'Alice', role: 'user' },
-      { name: 'Bob', role: 'user' }
-    ])
-
-    const [john, alice, bob] = users
-
-    const history = await History.find({})
-    expect(history).toHaveLength(0)
-
-    expect(em.emit).toHaveBeenCalledTimes(3)
-    expect(em.emit).toHaveBeenNthCalledWith(1, USER_CREATED, {
-      doc: expect.objectContaining({
-        _id: john._id,
-        name: john.name,
-        role: john.role,
-        createdAt: john.createdAt,
-        updatedAt: john.updatedAt
+  describe('upsert cases', () => {
+    it('should update() + upsert and emit one create event', async () => {
+      await User.update(
+        { name: 'John' },
+        { name: 'John', role: 'admin' },
+        { upsert: true }
+      )
+
+      const user = await User.findOne({ name: 'John', role: 'admin' })
+      expect(user).not.toBeNull()
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: user?._id,
+          name: user?.name,
+          role: user?.role
+        // Upsert does not set createdAt and updatedAt
+        })
+      })
+    })
+
+    it('should updateOne() + upsert and emit one create event', async () => {
+      await User.updateOne(
+        { name: 'John' },
+        { name: 'John', role: 'admin' },
+        { upsert: true }
+      )
+
+      const user = await User.findOne({ name: 'John', role: 'admin' })
+      expect(user).not.toBeNull()
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: user?._id,
+          name: user?.name,
+          role: user?.role
+        // Upsert does not set createdAt and updatedAt
+        })
+      })
+    })
+
+    it('should replaceOne() + upsert and emit one create event', async () => {
+      await User.replaceOne(
+        { name: 'John' },
+        { name: 'John', role: 'admin' },
+        { upsert: true }
+      )
+
+      const user = await User.findOne({ name: 'John', role: 'admin' })
+      expect(user).not.toBeNull()
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: user?._id,
+          name: user?.name,
+          role: user?.role
+          // Upsert does not set createdAt and updatedAt
+        })
       })
     })
-    expect(em.emit).toHaveBeenNthCalledWith(2, USER_CREATED, {
-      doc: expect.objectContaining({
-        _id: alice._id,
-        name: alice.name,
-        role: alice.role,
-        createdAt: alice.createdAt,
-        updatedAt: alice.updatedAt
+
+    it('should updateMany() + upsert and emit one create event', async () => {
+      await User.updateMany(
+        { name: { $in: ['John', 'Alice', 'Bob'] } },
+        { name: 'Steve', role: 'admin' },
+        { upsert: true }
+      )
+
+      const users = await User.findOne({ name: 'Steve', role: 'admin' })
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenNthCalledWith(1, USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: users?._id,
+          name: users?.name,
+          role: users?.role
+        // Upsert does not set createdAt and updatedAt
+        })
+      })
+    })
+
+    it('should findOneAndUpdate() + upsert and emit one create event', async () => {
+      await User.findOneAndUpdate(
+        { name: 'John' },
+        { name: 'John', role: 'admin' },
+        { upsert: true }
+      )
+
+      const user = await User.findOne({ name: 'John', role: 'admin' })
+      expect(user).not.toBeNull()
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: user?._id,
+          name: user?.name,
+          role: user?.role
+        // Upsert does not set createdAt and updatedAt
+        })
       })
     })
-    expect(em.emit).toHaveBeenNthCalledWith(3, USER_CREATED, {
-      doc: expect.objectContaining({
-        _id: bob._id,
-        name: bob.name,
-        role: bob.role,
-        createdAt: bob.createdAt,
-        updatedAt: bob.updatedAt
+
+    it('should findOneAndReplace() + upsert and emit one create event', async () => {
+      await User.findOneAndReplace(
+        { name: 'John' },
+        { name: 'John', role: 'admin' },
+        { upsert: true }
+      )
+
+      const user = await User.findOne({ name: 'John', role: 'admin' })
+      expect(user).not.toBeNull()
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: user?._id,
+          name: user?.name,
+          role: user?.role
+        // Upsert does not set createdAt and updatedAt
+        })
+      })
+    })
+
+    it('should findByIdAndUpdate() + upsert and emit one create event', async () => {
+      const _id = new Types.ObjectId()
+      await User.findByIdAndUpdate(_id, { name: 'John', role: 'admin' }, { upsert: true })
+
+      const user = await User.findOne({ name: 'John', role: 'admin' })
+      expect(user).not.toBeNull()
+
+      const history = await History.find({})
+      expect(history).toHaveLength(0)
+
+      expect(em.emit).toHaveBeenCalledTimes(1)
+      expect(em.emit).toHaveBeenCalledWith(USER_CREATED, {
+        doc: expect.objectContaining({
+          _id: user?._id,
+          name: user?.name,
+          role: user?.role
+        })
       })
     })
   })

package/tests/plugin-event-deleted.test.ts

@@ -1,5 +1,7 @@
 import mongoose, { model } from 'mongoose'
 
+import type { ToObjectOptions } from 'mongoose'
+
 import UserSchema from './schemas/UserSchema'
 import { patchHistoryPlugin } from '../src/plugin'
 import History from '../src/models/History'
@@ -13,6 +15,11 @@ jest.mock('../src/em', () => {
   }
 })
 
+const toObjectOptions: ToObjectOptions = {
+  depopulate: true,
+  virtuals: false
+}
+
 describe('plugin - event delete & patch history disabled', () => {
   const uri = `${globalThis.__MONGO_URI__}${globalThis.__MONGO_DB_NAME__}`
 
@@ -36,7 +43,20 @@ describe('plugin - event delete & patch history disabled', () => {
     await mongoose.connection.collection('history').deleteMany({})
   })
 
-  it('should deleteMany and emit two delete events', async () => {
+  it('should remove() and emit one delete event', async () => {
+    const john = await User.create({ name: 'John', role: 'user' })
+    await john.remove()
+
+    const history = await History.find({})
+    expect(history).toHaveLength(0)
+
+    expect(em.emit).toHaveBeenCalledTimes(1)
+    expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
+    })
+  })
+
+  it('should remove() and emit two delete events', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -45,21 +65,25 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john, alice] = users
 
-    await User.deleteMany({ role: 'user' }).exec()
+    await User.remove({ role: 'user' }).exec()
+
+    const remaining = await User.find({})
+
+    expect(remaining).toHaveLength(1)
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(2)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(alice.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(alice.toObject(toObjectOptions))
     })
   })
 
-  it('should deleteMany and emit one delete event { single: true }', async () => {
+  it('should remove() and emit one delete event { single: true }', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -68,18 +92,18 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.deleteMany({ role: 'user' }, { single: true }).exec()
+    await User.remove({ role: 'user' }, { single: true }).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 
-  it('should deleteOne and emit one delete event', async () => {
+  it('should findOneAndDelete() and emit one delete event', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -88,18 +112,18 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.deleteOne({ role: 'user' }).exec()
+    await User.findOneAndDelete({ role: 'user' }).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 
-  it('should findByIdAndDelete and emit one delete event', async () => {
+  it('should findOneAndRemove() and emit one delete event', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -108,18 +132,18 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.findByIdAndDelete(john._id).exec()
+    await User.findOneAndRemove({ role: 'user' }).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 
-  it('should findByIdAndRemove and emit one delete event', async () => {
+  it('should findByIdAndDelete() and emit one delete event', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -128,18 +152,18 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.findByIdAndRemove(john._id).exec()
+    await User.findByIdAndDelete(john._id).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 
-  it('should findOneAndDelete and emit one delete event', async () => {
+  it('should findByIdAndRemove() and emit one delete event', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -148,18 +172,18 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.findOneAndDelete({ role: 'user' }).exec()
+    await User.findByIdAndRemove(john._id).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 
-  it('should findOneAndRemove and emit one delete event', async () => {
+  it('should deleteOne() and emit one delete event', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -168,18 +192,18 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.findOneAndRemove({ role: 'user' }).exec()
+    await User.deleteOne({ role: 'user' }).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 
-  it('should remove and emit two delete events', async () => {
+  it('should deleteMany() and emit two delete events', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -188,25 +212,21 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john, alice] = users
 
-    await User.remove({ role: 'user' }).exec()
-
-    const remaining = await User.find({})
-
-    expect(remaining).toHaveLength(1)
+    await User.deleteMany({ role: 'user' }).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(2)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(alice.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(alice.toObject(toObjectOptions))
     })
   })
 
-  it('should remove and emit one delete event { single: true }', async () => {
+  it('should deleteMany() and emit one delete event { single: true }', async () => {
     const users = await User.create([
       { name: 'John', role: 'user' },
       { name: 'Alice', role: 'user' },
@@ -215,14 +235,14 @@ describe('plugin - event delete & patch history disabled', () => {
 
     const [john] = users
 
-    await User.remove({ role: 'user' }, { single: true }).exec()
+    await User.deleteMany({ role: 'user' }, { single: true }).exec()
 
     const history = await History.find({})
     expect(history).toHaveLength(0)
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 
@@ -235,20 +255,7 @@ describe('plugin - event delete & patch history disabled', () => {
 
     expect(em.emit).toHaveBeenCalledTimes(1)
     expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
-    })
-  })
-
-  it('should create then remove and emit one delete event', async () => {
-    const john = await User.create({ name: 'John', role: 'user' })
-    await john.remove()
-
-    const history = await History.find({})
-    expect(history).toHaveLength(0)
-
-    expect(em.emit).toHaveBeenCalledTimes(1)
-    expect(em.emit).toHaveBeenCalledWith(USER_DELETED, {
-      oldDoc: expect.objectContaining(john.toObject({ depopulate: true }))
+      oldDoc: expect.objectContaining(john.toObject(toObjectOptions))
     })
   })
 })