@declaro/data 2.0.0-beta.125 → 2.0.0-beta.127

package/src/domain/services/model-service.ts

@@ -12,8 +12,18 @@ import type { IModelServiceArgs } from './model-service-args'
 import { ReadOnlyModelService, type ILoadOptions } from './read-only-model-service'
 import type { IActionOptions } from './base-model-service'
 
-export interface ICreateOptions extends IActionOptions {}
-export interface IUpdateOptions extends IActionOptions {}
+export interface ICreateOptions extends IActionOptions {
+    /**
+     * If true, skips dispatching events for this action.
+     */
+    doNotDispatchEvents?: boolean
+}
+export interface IUpdateOptions extends IActionOptions {
+    /**
+     * If true, skips dispatching events for this action.
+     */
+    doNotDispatchEvents?: boolean
+}
 
 export interface INormalizeInputArgs<TSchema extends AnyModelSchema> {
     existing?: InferDetail<TSchema>
@@ -101,21 +111,25 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         })
 
         // Emit the before create event
-        const beforeCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.BeforeCreate),
-            normalizedInput,
-        )
-        await this.emitter.emitAsync(beforeCreateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.BeforeCreate),
+                normalizedInput,
+            )
+            await this.emitter.emitAsync(beforeCreateEvent)
+        }
 
         // Perform the creation
         const result = await this.repository.create(normalizedInput, options)
 
         // Emit the after create event
-        const afterCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.AfterCreate),
-            normalizedInput,
-        ).setResult(result)
-        await this.emitter.emitAsync(afterCreateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.AfterCreate),
+                normalizedInput,
+            ).setResult(result)
+            await this.emitter.emitAsync(afterCreateEvent)
+        }
 
         // Return the results of the creation
         return await this.normalizeDetail(result)
@@ -126,7 +140,7 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         input: InferInput<TSchema>,
         options?: IUpdateOptions,
     ): Promise<InferDetail<TSchema>> {
-        const existing = await this.repository.load(lookup, options)
+        const existing = await this.repository.load(lookup, { ...options, doNotDispatchEvents: true })
         // Normalize the input data
         const normalizedInput = await this.normalizeInput(input, {
             existing,
@@ -134,21 +148,25 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         })
 
         // Emit the before update event
-        const beforeUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.BeforeUpdate),
-            normalizedInput,
-        )
-        await this.emitter.emitAsync(beforeUpdateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.BeforeUpdate),
+                normalizedInput,
+            )
+            await this.emitter.emitAsync(beforeUpdateEvent)
+        }
 
         // Perform the update
         const result = await this.repository.update(lookup, normalizedInput, options)
 
         // Emit the after update event
-        const afterUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.AfterUpdate),
-            normalizedInput,
-        ).setResult(result)
-        await this.emitter.emitAsync(afterUpdateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.AfterUpdate),
+                normalizedInput,
+            ).setResult(result)
+            await this.emitter.emitAsync(afterUpdateEvent)
+        }
 
         // Return the results of the update
         return await this.normalizeDetail(result)
@@ -177,7 +195,10 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
                 {
                     [this.entityMetadata.primaryKey]: primaryKeyValue,
                 } as InferLookup<TSchema>,
-                options,
+                {
+                    ...options,
+                    doNotDispatchEvents: true,
+                },
             )
 
             if (existingItem) {
@@ -198,21 +219,25 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         })
 
         // Emit the before upsert event
-        const beforeUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(beforeOperation),
-            normalizedInput,
-        )
-        await this.emitter.emitAsync(beforeUpsertEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(beforeOperation),
+                normalizedInput,
+            )
+            await this.emitter.emitAsync(beforeUpsertEvent)
+        }
 
         // Perform the upsert operation
         const result = await this.repository.upsert(normalizedInput, options)
 
         // Emit the after upsert event
-        const afterUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(afterOperation),
-            normalizedInput,
-        ).setResult(result)
-        await this.emitter.emitAsync(afterUpsertEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(afterOperation),
+                normalizedInput,
+            ).setResult(result)
+            await this.emitter.emitAsync(afterUpsertEvent)
+        }
 
         // Return the results of the upsert operation
         return await this.normalizeDetail(result)
@@ -268,7 +293,10 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         const existingEntitiesMap = new Map<string | number, InferDetail<TSchema>>()
         if (uniqueLookups.size > 0) {
             const lookups = Array.from(uniqueLookups.values())
-            const existingEntities = await this.loadMany(lookups, options)
+            const existingEntities = await this.loadMany(lookups, {
+                ...options,
+                doNotDispatchEvents: true,
+            })
             existingEntities.forEach((entity) => {
                 if (entity) {
                     const pkValue = this.getPrimaryKeyValue(entity)
@@ -306,44 +334,48 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         const normalizedInputs = await Promise.all(normalizationPromises)
 
         // Create before events
-        const beforeEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
-        for (const inputInfo of inputInfos) {
-            beforeEvents.push(
-                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-                    this.getDescriptor(inputInfo.operation!),
-                    inputInfo.input,
-                ),
-            )
-        }
+        if (!options?.doNotDispatchEvents) {
+            const beforeEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
+            for (const inputInfo of inputInfos) {
+                beforeEvents.push(
+                    new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                        this.getDescriptor(inputInfo.operation!),
+                        inputInfo.input,
+                    ),
+                )
+            }
 
-        // Emit all before events
-        await Promise.all(beforeEvents.map((event) => this.emitter.emitAsync(event)))
+            // Emit all before events
+            await Promise.all(beforeEvents.map((event) => this.emitter.emitAsync(event)))
+        }
 
         // Perform the bulk upsert operation with all normalized inputs
         const results = await this.repository.bulkUpsert(normalizedInputs, options)
 
         // Create after events and return results
-        const afterEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
-
-        for (let i = 0; i < inputInfos.length; i++) {
-            const inputInfo = inputInfos[i]
-            const result = results[i]
-
-            const afterOperation =
-                inputInfo.operation === ModelMutationAction.BeforeCreate
-                    ? ModelMutationAction.AfterCreate
-                    : ModelMutationAction.AfterUpdate
-
-            afterEvents.push(
-                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-                    this.getDescriptor(afterOperation),
-                    inputInfo.input,
-                ).setResult(result),
-            )
-        }
+        if (!options?.doNotDispatchEvents) {
+            const afterEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
+
+            for (let i = 0; i < inputInfos.length; i++) {
+                const inputInfo = inputInfos[i]
+                const result = results[i]
+
+                const afterOperation =
+                    inputInfo.operation === ModelMutationAction.BeforeCreate
+                        ? ModelMutationAction.AfterCreate
+                        : ModelMutationAction.AfterUpdate
+
+                afterEvents.push(
+                    new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                        this.getDescriptor(afterOperation),
+                        inputInfo.input,
+                    ).setResult(result),
+                )
+            }
 
-        // Emit all after events
-        await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)))
+            // Emit all after events
+            await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)))
+        }
 
         // Return normalized results
         return await Promise.all(results.map((result) => this.normalizeDetail(result)))

package/src/domain/services/read-only-model-service.test.ts

@@ -825,4 +825,234 @@ describe('ReadOnlyModelService', () => {
             })
         })
     })
+
+    describe('doNotDispatchEvents Option', () => {
+        const beforeLoadSpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>) => {},
+        )
+        const afterLoadSpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>) => {},
+        )
+
+        const beforeLoadManySpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>) => {},
+        )
+        const afterLoadManySpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>) => {},
+        )
+
+        const beforeSearchSpy = mock(
+            (event: QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>) => {},
+        )
+        const afterSearchSpy = mock(
+            (event: QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>) => {},
+        )
+
+        const beforeCountSpy = mock((event: QueryEvent<number, InferFilters<typeof mockSchema>>) => {})
+        const afterCountSpy = mock((event: QueryEvent<number, InferFilters<typeof mockSchema>>) => {})
+
+        beforeEach(() => {
+            repository = new MockMemoryRepository({ schema: mockSchema })
+            emitter = new EventManager()
+
+            beforeLoadSpy.mockClear()
+            afterLoadSpy.mockClear()
+            beforeLoadManySpy.mockClear()
+            afterLoadManySpy.mockClear()
+            beforeSearchSpy.mockClear()
+            afterSearchSpy.mockClear()
+            beforeCountSpy.mockClear()
+            afterCountSpy.mockClear()
+
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>>(
+                'books::book.beforeLoad',
+                beforeLoadSpy,
+            )
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>>(
+                'books::book.afterLoad',
+                afterLoadSpy,
+            )
+
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>>(
+                'books::book.beforeLoadMany',
+                beforeLoadManySpy,
+            )
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>>(
+                'books::book.afterLoadMany',
+                afterLoadManySpy,
+            )
+
+            emitter.on<QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>>(
+                'books::book.beforeSearch',
+                beforeSearchSpy,
+            )
+            emitter.on<QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>>(
+                'books::book.afterSearch',
+                afterSearchSpy,
+            )
+
+            emitter.on<QueryEvent<number, InferFilters<typeof mockSchema>>>('books::book.beforeCount', beforeCountSpy)
+            emitter.on<QueryEvent<number, InferFilters<typeof mockSchema>>>('books::book.afterCount', afterCountSpy)
+
+            service = new ReadOnlyModelService({ repository, emitter, schema: mockSchema, namespace })
+        })
+
+        describe('load', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input = { id: 1, title: 'Test Book', author: 'Author', publishedDate: new Date() }
+                await repository.create(input)
+
+                const result = await service.load({ id: 1 }, { doNotDispatchEvents: true })
+
+                expect(result).toEqual(input)
+                expect(beforeLoadSpy).not.toHaveBeenCalled()
+                expect(afterLoadSpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input = { id: 2, title: 'Test Book 2', author: 'Author', publishedDate: new Date() }
+                await repository.create(input)
+
+                const result = await service.load({ id: 2 }, { doNotDispatchEvents: false })
+
+                expect(result).toEqual(input)
+                expect(beforeLoadSpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadSpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input = { id: 3, title: 'Test Book 3', author: 'Author', publishedDate: new Date() }
+                await repository.create(input)
+
+                const result = await service.load({ id: 3 })
+
+                expect(result).toEqual(input)
+                expect(beforeLoadSpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadSpy).toHaveBeenCalledTimes(1)
+            })
+        })
+
+        describe('loadMany', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input1 = { id: 1, title: 'Test Book 1', author: 'Author 1', publishedDate: new Date() }
+                const input2 = { id: 2, title: 'Test Book 2', author: 'Author 2', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.loadMany([{ id: 1 }, { id: 2 }], { doNotDispatchEvents: true })
+
+                expect(result).toEqual([input1, input2])
+                expect(beforeLoadManySpy).not.toHaveBeenCalled()
+                expect(afterLoadManySpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input1 = { id: 3, title: 'Test Book 3', author: 'Author 3', publishedDate: new Date() }
+                const input2 = { id: 4, title: 'Test Book 4', author: 'Author 4', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.loadMany([{ id: 3 }, { id: 4 }], { doNotDispatchEvents: false })
+
+                expect(result).toEqual([input1, input2])
+                expect(beforeLoadManySpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadManySpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input1 = { id: 5, title: 'Test Book 5', author: 'Author 5', publishedDate: new Date() }
+                const input2 = { id: 6, title: 'Test Book 6', author: 'Author 6', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.loadMany([{ id: 5 }, { id: 6 }])
+
+                expect(result).toEqual([input1, input2])
+                expect(beforeLoadManySpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadManySpy).toHaveBeenCalledTimes(1)
+            })
+        })
+
+        describe('search', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input1 = { id: 1, title: 'Test Book 1', author: 'Author 1', publishedDate: new Date() }
+                const input2 = { id: 2, title: 'Test Book 2', author: 'Author 2', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.search({}, { doNotDispatchEvents: true })
+
+                expect(result.results).toEqual([input1, input2])
+                expect(beforeSearchSpy).not.toHaveBeenCalled()
+                expect(afterSearchSpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input1 = { id: 3, title: 'Test Book 3', author: 'Author 3', publishedDate: new Date() }
+                const input2 = { id: 4, title: 'Test Book 4', author: 'Author 4', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.search({}, { doNotDispatchEvents: false })
+
+                expect(result.results).toEqual([input1, input2])
+                expect(beforeSearchSpy).toHaveBeenCalledTimes(1)
+                expect(afterSearchSpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input1 = { id: 5, title: 'Test Book 5', author: 'Author 5', publishedDate: new Date() }
+                const input2 = { id: 6, title: 'Test Book 6', author: 'Author 6', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.search({})
+
+                expect(result.results).toEqual([input1, input2])
+                expect(beforeSearchSpy).toHaveBeenCalledTimes(1)
+                expect(afterSearchSpy).toHaveBeenCalledTimes(1)
+            })
+        })
+
+        describe('count', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input1 = { id: 1, title: 'Test Book 1', author: 'Author 1', publishedDate: new Date() }
+                const input2 = { id: 2, title: 'Test Book 2', author: 'Author 2', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.count({}, { doNotDispatchEvents: true })
+
+                expect(result).toBe(2)
+                expect(beforeCountSpy).not.toHaveBeenCalled()
+                expect(afterCountSpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input1 = { id: 3, title: 'Test Book 3', author: 'Author 3', publishedDate: new Date() }
+                const input2 = { id: 4, title: 'Test Book 4', author: 'Author 4', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.count({}, { doNotDispatchEvents: false })
+
+                expect(result).toBe(2)
+                expect(beforeCountSpy).toHaveBeenCalledTimes(1)
+                expect(afterCountSpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input1 = { id: 5, title: 'Test Book 5', author: 'Author 5', publishedDate: new Date() }
+                const input2 = { id: 6, title: 'Test Book 6', author: 'Author 6', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.count({})
+
+                expect(result).toBe(2)
+                expect(beforeCountSpy).toHaveBeenCalledTimes(1)
+                expect(afterCountSpy).toHaveBeenCalledTimes(1)
+            })
+        })
+    })
 })

package/src/domain/services/read-only-model-service.ts

@@ -23,6 +23,11 @@ export interface ILoadOptions extends IActionOptions {
      * If true, both removed and non-removed records will be returned.
      */
     includeRemoved?: boolean
+
+    /**
+     * If true, skips dispatching events for this action.
+     */
+    doNotDispatchEvents?: boolean
 }
 export interface ISearchOptions<TSchema extends AnyModelSchema> extends IActionOptions {
     pagination?: IPaginationInput
@@ -35,6 +40,10 @@ export interface ISearchOptions<TSchema extends AnyModelSchema> extends IActionO
      * If true, both removed and non-removed records will be returned.
      */
     includeRemoved?: boolean
+    /**
+     * If true, skips dispatching events for this action.
+     */
+    doNotDispatchEvents?: boolean
 }
 
 export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseModelService<TSchema> {
@@ -69,21 +78,25 @@ export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseMo
      */
     async load(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferDetail<TSchema>> {
         // Emit the before load event
-        const beforeLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
-            this.getDescriptor(ModelQueryEvent.BeforeLoad, options?.scope),
-            lookup,
-        )
-        await this.emitter.emitAsync(beforeLoadEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
+                this.getDescriptor(ModelQueryEvent.BeforeLoad, options?.scope),
+                lookup,
+            )
+            await this.emitter.emitAsync(beforeLoadEvent)
+        }
 
         // Load the details from the repository
         const details = await this.repository.load(lookup, options)
 
         // Emit the after load event
-        const afterLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
-            this.getDescriptor(ModelQueryEvent.AfterLoad, options?.scope),
-            lookup,
-        ).setResult(details)
-        await this.emitter.emitAsync(afterLoadEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
+                this.getDescriptor(ModelQueryEvent.AfterLoad, options?.scope),
+                lookup,
+            ).setResult(details)
+            await this.emitter.emitAsync(afterLoadEvent)
+        }
 
         return await this.normalizeDetail(details)
     }
@@ -96,21 +109,25 @@ export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseMo
      */
     async loadMany(lookups: InferLookup<TSchema>[], options?: ILoadOptions): Promise<InferDetail<TSchema>[]> {
         // Emit the before load many event
-        const beforeLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
-            this.getDescriptor(ModelQueryEvent.BeforeLoadMany, options?.scope),
-            lookups,
-        )
-        await this.emitter.emitAsync(beforeLoadManyEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
+                this.getDescriptor(ModelQueryEvent.BeforeLoadMany, options?.scope),
+                lookups,
+            )
+            await this.emitter.emitAsync(beforeLoadManyEvent)
+        }
 
         // Load the details from the repository
         const details = await this.repository.loadMany(lookups, options)
 
         // Emit the after load many event
-        const afterLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
-            this.getDescriptor(ModelQueryEvent.AfterLoadMany, options?.scope),
-            lookups,
-        ).setResult(details)
-        await this.emitter.emitAsync(afterLoadManyEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
+                this.getDescriptor(ModelQueryEvent.AfterLoadMany, options?.scope),
+                lookups,
+            ).setResult(details)
+            await this.emitter.emitAsync(afterLoadManyEvent)
+        }
 
         return await Promise.all(details.map((detail) => this.normalizeDetail(detail)))
     }
@@ -126,21 +143,25 @@ export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseMo
         options?: ISearchOptions<TSchema>,
     ): Promise<InferSearchResults<TSchema>> {
         // Emit the before search event
-        const beforeSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
-            this.getDescriptor(ModelQueryEvent.BeforeSearch, options?.scope),
-            filters,
-        )
-        await this.emitter.emitAsync(beforeSearchEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
+                this.getDescriptor(ModelQueryEvent.BeforeSearch, options?.scope),
+                filters,
+            )
+            await this.emitter.emitAsync(beforeSearchEvent)
+        }
 
         // Search the repository with the provided filters
         const results = await this.repository.search(filters, options)
 
         // Emit the after search event
-        const afterSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
-            this.getDescriptor(ModelQueryEvent.AfterSearch, options?.scope),
-            filters,
-        ).setResult(results)
-        await this.emitter.emitAsync(afterSearchEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
+                this.getDescriptor(ModelQueryEvent.AfterSearch, options?.scope),
+                filters,
+            ).setResult(results)
+            await this.emitter.emitAsync(afterSearchEvent)
+        }
 
         // Return the search results
         return {
@@ -156,21 +177,25 @@ export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseMo
      */
     async count(filters: InferFilters<TSchema>, options?: ISearchOptions<TSchema>): Promise<number> {
         // Emit the before count event
-        const beforeCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
-            this.getDescriptor(ModelQueryEvent.BeforeCount, options?.scope),
-            filters,
-        )
-        await this.emitter.emitAsync(beforeCountEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
+                this.getDescriptor(ModelQueryEvent.BeforeCount, options?.scope),
+                filters,
+            )
+            await this.emitter.emitAsync(beforeCountEvent)
+        }
 
         // Count the records in the repository
         const count = await this.repository.count(filters, options)
 
         // Emit the after count event
-        const afterCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
-            this.getDescriptor(ModelQueryEvent.AfterCount, options?.scope),
-            filters,
-        ).setResult(count)
-        await this.emitter.emitAsync(afterCountEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
+                this.getDescriptor(ModelQueryEvent.AfterCount, options?.scope),
+                filters,
+            ).setResult(count)
+            await this.emitter.emitAsync(afterCountEvent)
+        }
 
         // Return the count
         return count