ts-patch-mongoose 2.7.0 → 2.8.0

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

@@ -1,17 +1,16 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
-
 import mongoose, { Types, model } from 'mongoose'
-import { isMongooseLessThan7 } from '../src/version'
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import History from '../src/models/History'
 import { patchHistoryPlugin } from '../src/plugin'
-import UserSchema from './schemas/UserSchema'
-
-import { USER_CREATED } from './constants/events'
+import { isMongooseLessThan7 } from '../src/version'
 
 import em from '../src/em'
+import { USER_CREATED } from './constants/events'
 import server from './mongo/server'
 
+import { HistoryModel } from '../src/models/History'
+import { type User, UserSchema } from './schemas/User'
+
 vi.mock('../src/em', () => ({ default: { emit: vi.fn((event: string, data: Record<string, unknown>) => console.log(event, data)) } }))
 
 describe('plugin - event created & patch history disabled', () => {
@@ -22,7 +21,7 @@ describe('plugin - event created & patch history disabled', () => {
     patchHistoryDisabled: true,
   })
 
-  const User = model('User', UserSchema)
+  const UserModel = model<User>('User', UserSchema)
 
   beforeAll(async () => {
     await instance.create()
@@ -43,10 +42,10 @@ describe('plugin - event created & patch history disabled', () => {
 
   describe('normal cases', () => {
     it('should save() and emit one create event', async () => {
-      const john = new User({ name: 'John', role: 'user' })
+      const john = new UserModel({ name: 'John', role: 'user' })
       await john.save()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -61,16 +60,16 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('user')
     })
 
     it('should create() and emit one create event', async () => {
-      const user = await User.create({ name: 'John', role: 'user' })
+      const user = await UserModel.create({ name: 'John', role: 'user' })
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -85,14 +84,14 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('user')
     })
 
     it('should insertMany() and emit three create events', async () => {
-      const users = await User.insertMany(
+      const users = await UserModel.insertMany(
         [
           { name: 'John', role: 'user' },
           { name: 'Alice', role: 'user' },
@@ -103,7 +102,7 @@ describe('plugin - event created & patch history disabled', () => {
 
       const [john, alice, bob] = users
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(3)
@@ -136,7 +135,7 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the documents are saved
-      const found = await User.find({})
+      const found = await UserModel.find({})
       expect(found).toHaveLength(3)
 
       const [foundJohn, foundAlice, foundBob] = found
@@ -156,15 +155,15 @@ describe('plugin - event created & patch history disabled', () => {
     it('should update() + upsert and emit one create event', async () => {
       if (isMongooseLessThan7) {
         // @ts-expect-error update() not available in Mongoose v6 and below
-        await User.update({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
+        await UserModel.update({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
       } else {
-        await User.findOneAndUpdate({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
+        await UserModel.findOneAndUpdate({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
       }
 
-      const user = await User.findOne({ name: 'John', role: 'admin' })
+      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
       expect(user).not.toBeNull()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -178,19 +177,19 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('admin')
     })
 
     it('should updateOne() + upsert and emit one create event', async () => {
-      await User.updateOne({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
+      await UserModel.updateOne({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
 
-      const user = await User.findOne({ name: 'John', role: 'admin' })
+      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
       expect(user).not.toBeNull()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -204,19 +203,19 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('admin')
     })
 
     it('should replaceOne() + upsert and emit one create event', async () => {
-      await User.replaceOne({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
+      await UserModel.replaceOne({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
 
-      const user = await User.findOne({ name: 'John', role: 'admin' })
+      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
       expect(user).not.toBeNull()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -230,18 +229,18 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('admin')
     })
 
     it('should updateMany() + upsert and emit one create event', async () => {
-      await User.updateMany({ name: { $in: ['John', 'Alice', 'Bob'] } }, { name: 'Steve', role: 'admin' }, { upsert: true })
+      await UserModel.updateMany({ name: { $in: ['John', 'Alice', 'Bob'] } }, { name: 'Steve', role: 'admin' }, { upsert: true })
 
-      const users = await User.findOne({ name: 'Steve', role: 'admin' })
+      const users = await UserModel.findOne({ name: 'Steve', role: 'admin' })
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -255,19 +254,19 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findById(users?._id)
+      const found = await UserModel.findById(users?._id)
       expect(found).not.toBeNull()
       expect(found?.name).toBe('Steve')
       expect(found?.role).toBe('admin')
     })
 
     it('should findOneAndUpdate() + upsert and emit one create event', async () => {
-      await User.findOneAndUpdate({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
+      await UserModel.findOneAndUpdate({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
 
-      const user = await User.findOne({ name: 'John', role: 'admin' })
+      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
       expect(user).not.toBeNull()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -281,19 +280,19 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('admin')
     })
 
     it('should findOneAndReplace() + upsert and emit one create event', async () => {
-      await User.findOneAndReplace({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
+      await UserModel.findOneAndReplace({ name: 'John' }, { name: 'John', role: 'admin' }, { upsert: true })
 
-      const user = await User.findOne({ name: 'John', role: 'admin' })
+      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
       expect(user).not.toBeNull()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -307,7 +306,7 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('admin')
@@ -315,12 +314,12 @@ describe('plugin - event created & patch history disabled', () => {
 
     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 })
+      await UserModel.findByIdAndUpdate(_id, { name: 'John', role: 'admin' }, { upsert: true })
 
-      const user = await User.findOne({ name: 'John', role: 'admin' })
+      const user = await UserModel.findOne({ name: 'John', role: 'admin' })
       expect(user).not.toBeNull()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(1)
@@ -333,7 +332,7 @@ describe('plugin - event created & patch history disabled', () => {
       })
 
       // Check if the document is saved
-      const found = await User.findOne({})
+      const found = await UserModel.findOne({})
       expect(found).not.toBeNull()
       expect(found?.name).toBe('John')
       expect(found?.role).toBe('admin')
@@ -341,19 +340,19 @@ describe('plugin - event created & patch history disabled', () => {
 
     it('should findOneAndUpdate() with $set + upsert and emit one create event', async () => {
       const _id = new Types.ObjectId()
-      const john = await User.create({ _id, name: 'John', role: 'admin' })
+      const john = await UserModel.create({ _id, name: 'John', role: 'admin' })
 
       if (isMongooseLessThan7) {
         // @ts-expect-error update() not available in Mongoose v6 and below
-        await User.update({ name: 'Alex', role: 'user' }, { $set: { name: 'Alex', role: 'user' } }, { upsert: true, setDefaultsOnInsert: false, overwriteDiscriminatorKey: true }).exec()
+        await UserModel.update({ name: 'Alex', role: 'user' }, { $set: { name: 'Alex', role: 'user' } }, { upsert: true, setDefaultsOnInsert: false, overwriteDiscriminatorKey: true }).exec()
       } else {
-        await User.findOneAndUpdate({ name: 'Alex', role: 'user' }, { $set: { name: 'Alex', role: 'user' } }, { upsert: true, setDefaultsOnInsert: false, overwriteDiscriminatorKey: true }).exec()
+        await UserModel.findOneAndUpdate({ name: 'Alex', role: 'user' }, { $set: { name: 'Alex', role: 'user' } }, { upsert: true, setDefaultsOnInsert: false, overwriteDiscriminatorKey: true }).exec()
       }
 
-      const alex = await User.findOne({ name: 'Alex', role: 'user' })
+      const alex = await UserModel.findOne({ name: 'Alex', role: 'user' })
       expect(alex).not.toBeNull()
 
-      const history = await History.find({})
+      const history = await HistoryModel.find({})
       expect(history).toHaveLength(0)
 
       expect(em.emit).toHaveBeenCalledTimes(2)