ts-patch-mongoose 2.7.1 → 2.8.0

package/src/plugin.ts

@@ -10,31 +10,38 @@ import { saveHooksInitialize } from './hooks/save-hooks'
 import { updateHooksInitialize } from './hooks/update-hooks'
 
 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'
 
 const remove = isMongooseLessThan7 ? 'remove' : 'deleteOne'
 
 /**
- * @description Patch patch event emitter
+ * @description Event emitter for patch operations.
  */
 export const patchEventEmitter = em
 
 export { setPatchHistoryTTL } from './helpers'
 
 /**
- * @description Patch history plugin
- * @param {Schema} schema
- * @param {IPluginOptions} opts
+ * @description Mongoose plugin to track and manage patch history for documents.
+ * This plugin initializes hooks for save, update, and delete operations to create
+ * and manage patches.
+ *
+ * @template T
+ * @param {Schema<T>} schema - The Mongoose schema to apply the plugin to.
+ * @param {PluginOptions<T>} opts - Options for configuring the plugin.
  * @returns {void}
  */
-export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: IPluginOptions<T>): void {
+export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: PluginOptions<T>): void {
   // Initialize hooks
   saveHooksInitialize(schema, opts)
   updateHooksInitialize(schema, opts)
   deleteHooksInitialize(schema, opts)
 
-  // Corner case for insertMany()
+  /**
+   * @description Corner case for insertMany()
+   * @param {Array<HydratedDocument<T>>} docs - The documents being inserted.
+   * @returns {Promise<void>}
+   */
   schema.post('insertMany', async function (docs) {
     const context = {
       op: 'create',
@@ -49,6 +56,10 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: IP
   // In Mongoose 7, doc.deleteOne() returned a promise that resolved to doc.
   // In Mongoose 8, doc.deleteOne() returns a query for easier chaining, as well as consistency with doc.updateOne().
   if (isMongooseLessThan8) {
+    /**
+     * @description Pre-delete hook for Mongoose 7 and below
+     * @returns {Promise<void>}
+     */
     // @ts-expect-error - Mongoose 7 and below
     schema.pre(remove, { document: true, query: false }, async function () {
       // @ts-expect-error - Mongoose 7 and below
@@ -59,12 +70,17 @@ export const patchHistoryPlugin = function plugin<T>(schema: Schema<T>, opts: IP
       }
     })
 
+    /**
+     * @description Post-delete hook for Mongoose 7 and below
+     * @param {HydratedDocument<T>} this - The document being deleted.
+     * @returns {Promise<void>}
+     */
     // @ts-expect-error - Mongoose 7 and below
     schema.post(remove, { document: true, query: false }, async function (this: HydratedDocument<T>) {
       const original = this.toObject(toObjectOptions) as HydratedDocument<T>
       const model = this.constructor as Model<T>
 
-      const context: IContext<T> = {
+      const context: PatchContext<T> = {
         op: 'delete',
         modelName: opts.modelName ?? model.modelName,
         collectionName: opts.collectionName ?? model.collection.collectionName,

package/src/types.ts

@@ -0,0 +1,52 @@
+import type { Operation } from 'fast-json-patch'
+import type { HydratedDocument, Query, Types } from 'mongoose'
+
+export interface History {
+  op: string
+  modelName: string
+  collectionName: string
+  collectionId: Types.ObjectId
+  version: number
+  doc?: object
+  user?: object
+  reason?: string
+  metadata?: object
+  patch?: Operation[]
+}
+
+export interface PatchEvent<T> {
+  oldDoc?: HydratedDocument<T>
+  doc?: HydratedDocument<T>
+  patch?: Operation[]
+}
+
+export interface PatchContext<T> {
+  op: string
+  modelName: string
+  collectionName: string
+  isNew?: boolean
+  createdDocs?: HydratedDocument<T>[]
+  deletedDocs?: HydratedDocument<T>[]
+  ignoreEvent?: boolean
+  ignorePatchHistory?: boolean
+}
+
+export type HookContext<T> = Query<T, T> & { op: string; _context: PatchContext<T> }
+
+export type User = Record<string, unknown>
+
+export type Metadata = Record<string, unknown>
+
+export interface PluginOptions<T> {
+  modelName?: string
+  collectionName?: string
+  eventUpdated?: string
+  eventCreated?: string
+  eventDeleted?: string
+  getUser?: () => Promise<User> | User
+  getReason?: () => Promise<string> | string
+  getMetadata?: () => Promise<Metadata> | Metadata
+  omit?: string[]
+  patchHistoryDisabled?: boolean
+  preDelete?: (docs: HydratedDocument<T>[]) => Promise<void>
+}

package/tests/helpers.test.ts

@@ -1,14 +1,13 @@
 import ms from 'ms'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import History from '../src/models/History'
-
 import { setPatchHistoryTTL } from '../src/helpers'
+import { HistoryModel } from '../src/models/History'
 
 import type { Mock, MockInstance } from 'vitest'
 
 vi.mock('../src/models/History', () => ({
-  default: {
+  HistoryModel: {
     collection: {
       indexes: vi.fn(),
       dropIndex: vi.fn(),
@@ -22,12 +21,12 @@ const name = 'createdAt_1_TTL'
 describe('useTTL', () => {
   let dropIndexSpy: MockInstance
   let createIndexSpy: MockInstance
-  const indexes = History.collection.indexes as Mock
+  const indexes = HistoryModel.collection.indexes as Mock
 
   beforeEach(() => {
     vi.clearAllMocks()
-    dropIndexSpy = vi.spyOn(History.collection, 'dropIndex')
-    createIndexSpy = vi.spyOn(History.collection, 'createIndex')
+    dropIndexSpy = vi.spyOn(HistoryModel.collection, 'dropIndex')
+    createIndexSpy = vi.spyOn(HistoryModel.collection, 'createIndex')
   })
 
   afterEach(() => {

package/tests/patch.test.ts

@@ -1,23 +1,18 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import mongoose, { model } from 'mongoose'
+import mongoose from 'mongoose'
 
 import { bulkPatch, getData, getJsonOmit, getMetadata, getReason, getUser, getValue, updatePatch } from '../src/patch'
 import { patchHistoryPlugin } from '../src/plugin'
 
-import UserSchema from './schemas/UserSchema'
-
 import { USER_DELETED } from './constants/events'
+import { type User, UserSchema } from './schemas/User'
 
 import type { HydratedDocument } from 'mongoose'
-import type IContext from '../src/interfaces/IContext'
-import type { User } from '../src/interfaces/IPluginOptions'
-import type IPluginOptions from '../src/interfaces/IPluginOptions'
-import type IUser from './interfaces/IUser'
 
 import { afterEach } from 'node:test'
-import { update } from 'lodash'
 import em from '../src/em'
+import type { PatchContext, PluginOptions } from '../src/types'
 import server from './mongo/server'
 
 vi.mock('../src/em', () => ({ default: { emit: vi.fn() } }))
@@ -30,7 +25,7 @@ describe('patch tests', () => {
     patchHistoryDisabled: true,
   })
 
-  const User = model('User', UserSchema)
+  const UserModel = mongoose.model<User>('User', UserSchema)
 
   beforeAll(async () => {
     await instance.create()
@@ -51,8 +46,8 @@ describe('patch tests', () => {
 
   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 original = await UserModel.create({ name: 'John', role: 'user' })
+      const current = await UserModel.create({ name: 'John', role: 'admin' })
 
       const pluginOptions = {
         omit: ['createdAt'],
@@ -71,8 +66,8 @@ describe('patch tests', () => {
     })
 
     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 original = await UserModel.create({ name: 'John', role: 'user' })
+      const current = await UserModel.create({ name: 'John', role: 'admin' })
 
       const pluginOptions = {}
 
@@ -91,14 +86,14 @@ describe('patch tests', () => {
 
   describe('bulkPatch', () => {
     it('should emit eventDeleted if opts.patchHistoryDisabled is false', async () => {
-      const doc = new User({ name: 'John', role: 'user' })
+      const doc = new UserModel({ name: 'John', role: 'user' })
 
-      const pluginOptions: IPluginOptions<IUser> = {
+      const pluginOptions: PluginOptions<User> = {
         eventDeleted: USER_DELETED,
         patchHistoryDisabled: false,
       }
 
-      const context: IContext<IUser> = {
+      const context: PatchContext<User> = {
         op: 'deleteOne',
         modelName: 'User',
         collectionName: 'users',
@@ -110,14 +105,14 @@ describe('patch tests', () => {
     })
 
     it('should emit eventDeleted if opts.patchHistoryDisabled is true', async () => {
-      const doc = new User({ name: 'John', role: 'user' })
+      const doc = new UserModel({ name: 'John', role: 'user' })
 
-      const pluginOptions: IPluginOptions<IUser> = {
+      const pluginOptions: PluginOptions<User> = {
         eventDeleted: USER_DELETED,
         patchHistoryDisabled: true,
       }
 
-      const context: IContext<IUser> = {
+      const context: PatchContext<User> = {
         op: 'deleteOne',
         modelName: 'User',
         collectionName: 'users',
@@ -131,27 +126,27 @@ describe('patch tests', () => {
 
   describe('updatePatch', () => {
     it('should return if one object is empty', async () => {
-      const current = await User.create({ name: 'John', role: 'user' })
+      const current = await UserModel.create({ name: 'John', role: 'user' })
 
-      const pluginOptions: IPluginOptions<IUser> = {
+      const pluginOptions: PluginOptions<User> = {
         eventDeleted: USER_DELETED,
         patchHistoryDisabled: true,
       }
 
-      const context: IContext<IUser> = {
+      const context: PatchContext<User> = {
         op: 'updateOne',
         modelName: 'User',
         collectionName: 'users',
       }
 
-      await updatePatch(pluginOptions, context, current, {} as HydratedDocument<IUser>)
+      await updatePatch(pluginOptions, context, current, {} as HydratedDocument<User>)
       expect(em.emit).toHaveBeenCalled()
     })
   })
 
   describe('should getUser()', () => {
     it('should return user, reason, metadata', async () => {
-      const opts: IPluginOptions<IUser> = {
+      const opts: PluginOptions<User> = {
         getUser: () => ({ name: 'test' }),
         getReason: () => 'test',
         getMetadata: () => ({ test: 'test' }),
@@ -165,7 +160,7 @@ describe('patch tests', () => {
 
   describe('should getData()', () => {
     it('should return user, reason, metadata', async () => {
-      const opts: IPluginOptions<IUser> = {
+      const opts: PluginOptions<User> = {
         getUser: () => ({ name: 'test' }),
         getReason: () => 'test',
         getMetadata: () => ({ test: 'test' }),
@@ -175,7 +170,7 @@ describe('patch tests', () => {
     })
 
     it('should return user, reason, metadata undefined', async () => {
-      const opts: IPluginOptions<IUser> = {
+      const opts: PluginOptions<User> = {
         getUser: () => ({ name: 'test' }),
         getReason: () => 'test',
         getMetadata: () => {

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)