@declaro/data 2.0.0-beta.11 → 2.0.0-beta.110

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

@@ -0,0 +1,345 @@
+import type { AnyModelSchema } from '@declaro/core'
+import type { InferDetail, InferInput, InferLookup, InferSummary } from '../../shared/utils/schema-inference'
+import { ModelMutationAction, ModelQueryEvent } from '../events/event-types'
+import { MutationEvent } from '../events/mutation-event'
+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 class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelService<TSchema> {
+    constructor(args: IModelServiceArgs<TSchema>) {
+        super(args)
+    }
+
+    /**
+     * Normalizes input data before processing. This method can be overridden by subclasses
+     * to implement custom input normalization logic (e.g., trimming strings, setting defaults, etc.).
+     * By default, this method returns the input unchanged.
+     * @param input The input data to normalize.
+     * @returns The normalized input data.
+     */
+    protected async normalizeInput(input: InferInput<TSchema>): Promise<InferInput<TSchema>> {
+        return input
+    }
+
+    /**
+     * Removes a record by its lookup criteria.
+     * @param lookup The lookup criteria to find the record.
+     * @returns The removed record.
+     */
+    async remove(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferSummary<TSchema>> {
+        // Emit the before remove event
+        const beforeRemoveEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.BeforeRemove),
+            lookup,
+        )
+        await this.emitter.emitAsync(beforeRemoveEvent)
+
+        // Perform the removal
+        const result = await this.repository.remove(lookup, options)
+
+        // Emit the after remove event
+        const afterRemoveEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.AfterRemove),
+            lookup,
+        ).setResult(result)
+        await this.emitter.emitAsync(afterRemoveEvent)
+
+        // Return the results of the removal
+        return result
+    }
+
+    /**
+     * Restores a record by its lookup criteria.
+     * If a soft-deleted copy exists, it will be restored.
+     * @param lookup The lookup criteria to find the record to restore.
+     * @returns
+     */
+    async restore(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferSummary<TSchema>> {
+        // Emit the before restore event
+        const beforeRestoreEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.BeforeRestore),
+            lookup,
+        )
+        await this.emitter.emitAsync(beforeRestoreEvent)
+
+        // Perform the restore operation
+        const result = await this.repository.restore(lookup, options)
+
+        // Emit the after restore event
+        const afterRestoreEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.AfterRestore),
+            lookup,
+        ).setResult(result)
+        await this.emitter.emitAsync(afterRestoreEvent)
+
+        // Return the results of the restore operation
+        return result
+    }
+
+    async create(input: InferInput<TSchema>, options?: ICreateOptions): Promise<InferDetail<TSchema>> {
+        // Normalize the input data
+        const normalizedInput = await this.normalizeInput(input)
+
+        // Emit the before create event
+        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)
+
+        // Return the results of the creation
+        return result
+    }
+
+    async update(
+        lookup: InferLookup<TSchema>,
+        input: InferInput<TSchema>,
+        options?: IUpdateOptions,
+    ): Promise<InferDetail<TSchema>> {
+        // Normalize the input data
+        const normalizedInput = await this.normalizeInput(input)
+
+        // Emit the before update event
+        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)
+
+        // Return the results of the update
+        return result
+    }
+
+    /**
+     * Upserts a record (creates if it doesn't exist, updates if it does).
+     * @param input The input data for the upsert operation.
+     * @param options Optional create or update options.
+     * @returns The upserted record.
+     */
+    async upsert(input: InferInput<TSchema>, options?: ICreateOptions | IUpdateOptions): Promise<InferDetail<TSchema>> {
+        // Normalize the input data
+        const normalizedInput = await this.normalizeInput(input)
+
+        const primaryKeyValue = this.getPrimaryKeyValue(normalizedInput)
+
+        let beforeOperation: ModelMutationAction
+        let afterOperation: ModelMutationAction
+
+        if (primaryKeyValue === undefined) {
+            beforeOperation = ModelMutationAction.BeforeCreate
+            afterOperation = ModelMutationAction.AfterCreate
+        } else {
+            const existingItem = await this.load(
+                {
+                    [this.entityMetadata.primaryKey]: primaryKeyValue,
+                } as InferLookup<TSchema>,
+                options,
+            )
+
+            if (existingItem) {
+                beforeOperation = ModelMutationAction.BeforeUpdate
+                afterOperation = ModelMutationAction.AfterUpdate
+            } else {
+                beforeOperation = ModelMutationAction.BeforeCreate
+                afterOperation = ModelMutationAction.AfterCreate
+            }
+        }
+
+        // Emit the before upsert event
+        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)
+
+        // Return the results of the upsert operation
+        return result
+    }
+
+    /**
+     * Bulk upserts multiple records (creates if they don't exist, updates if they do).
+     * @param inputs Array of input data for the bulk upsert operation.
+     * @param options Optional create or update options.
+     * @returns Array of upserted records.
+     */
+    async bulkUpsert(
+        inputs: InferInput<TSchema>[],
+        options?: ICreateOptions | IUpdateOptions,
+    ): Promise<InferDetail<TSchema>[]> {
+        if (inputs.length === 0) {
+            return []
+        }
+
+        // Normalize all input data in parallel using Promise.all
+        const normalizedInputs = await Promise.all(inputs.map((input) => this.normalizeInput(input)))
+
+        // Build a map of primary key to input and lookup info
+        type EntityInfo = {
+            input: InferInput<TSchema>
+            lookup: InferLookup<TSchema>
+            primaryKeyValue: string | number
+            existingEntity?: InferDetail<TSchema>
+            operation?: ModelMutationAction
+        }
+
+        const entityInfoMap = new Map<string | number, EntityInfo>()
+        const inputsWithoutPrimaryKey: InferInput<TSchema>[] = []
+
+        // Process each normalized input and organize by primary key
+        for (const input of normalizedInputs) {
+            const primaryKeyValue = this.getPrimaryKeyValue(input)
+
+            if (primaryKeyValue !== undefined) {
+                const entityInfo: EntityInfo = {
+                    input,
+                    primaryKeyValue,
+                    lookup: {
+                        [this.entityMetadata.primaryKey]: primaryKeyValue,
+                    } as InferLookup<TSchema>,
+                }
+                entityInfoMap.set(primaryKeyValue, entityInfo)
+            } else {
+                // Inputs without primary keys are always creates
+                inputsWithoutPrimaryKey.push(input)
+            }
+        }
+
+        // Extract lookups for existing entities
+        const lookups = Array.from(entityInfoMap.values()).map((info) => info.lookup)
+
+        // Load existing entities and update the map
+        if (lookups.length > 0) {
+            const existingEntities = await this.loadMany(lookups, options)
+            existingEntities.forEach((entity) => {
+                if (entity) {
+                    const pkValue = this.getPrimaryKeyValue(entity)
+                    if (pkValue !== undefined && entityInfoMap.has(pkValue)) {
+                        const entityInfo = entityInfoMap.get(pkValue)!
+                        entityInfo.existingEntity = entity
+                    }
+                }
+            })
+        }
+
+        // Determine operation types and prepare before events
+        const beforeEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
+
+        // Handle entities with primary keys
+        for (const entityInfo of entityInfoMap.values()) {
+            const operation = entityInfo.existingEntity
+                ? ModelMutationAction.BeforeUpdate
+                : ModelMutationAction.BeforeCreate
+
+            entityInfo.operation = operation
+
+            beforeEvents.push(
+                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                    this.getDescriptor(operation),
+                    entityInfo.input,
+                ),
+            )
+        }
+
+        // Handle inputs without primary keys (always creates)
+        for (const input of inputsWithoutPrimaryKey) {
+            beforeEvents.push(
+                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                    this.getDescriptor(ModelMutationAction.BeforeCreate),
+                    input,
+                ),
+            )
+        }
+
+        // Emit all before events
+        await Promise.all(beforeEvents.map((event) => this.emitter.emitAsync(event)))
+
+        // Perform the bulk upsert operation with normalized inputs
+        const results = await this.repository.bulkUpsert(normalizedInputs, options)
+
+        // Create a map of result primary keys to results for matching
+        const resultsByPrimaryKey = new Map<string | number, InferDetail<TSchema>>()
+        const resultsWithoutPrimaryKey: InferDetail<TSchema>[] = []
+
+        for (const result of results) {
+            const pkValue = this.getPrimaryKeyValue(result)
+            if (pkValue !== undefined) {
+                resultsByPrimaryKey.set(pkValue, result)
+            } else {
+                resultsWithoutPrimaryKey.push(result)
+            }
+        }
+
+        // Prepare after events by matching results back to original inputs
+        const afterEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
+        let resultsWithoutPkIndex = 0
+
+        // Handle entities with primary keys
+        for (const entityInfo of entityInfoMap.values()) {
+            const matchedResult = resultsByPrimaryKey.get(entityInfo.primaryKeyValue)!
+
+            const afterOperation =
+                entityInfo.operation === ModelMutationAction.BeforeCreate
+                    ? ModelMutationAction.AfterCreate
+                    : ModelMutationAction.AfterUpdate
+
+            afterEvents.push(
+                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                    this.getDescriptor(afterOperation),
+                    entityInfo.input,
+                ).setResult(matchedResult),
+            )
+        }
+
+        // Handle inputs without primary keys (always creates)
+        for (const input of inputsWithoutPrimaryKey) {
+            const matchedResult = resultsWithoutPrimaryKey[resultsWithoutPkIndex++]
+
+            afterEvents.push(
+                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                    this.getDescriptor(ModelMutationAction.AfterCreate),
+                    input,
+                ).setResult(matchedResult),
+            )
+        }
+
+        // Emit all after events
+        await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)))
+
+        // Return the results
+        return results
+    }
+}

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

@@ -0,0 +1,296 @@
+import { describe, it, expect, beforeEach, spyOn, mock } from 'bun:test'
+import { ReadOnlyModelService } from './read-only-model-service'
+import { MockMemoryRepository } from '../../test/mock/repositories/mock-memory-repository'
+import { MockBookSchema } from '../../test/mock/models/mock-book-models'
+import { EventManager } from '@declaro/core'
+import type { QueryEvent } from '../events/query-event'
+import type { InferDetail, InferFilters, InferLookup, InferSearchResults } from '../../shared/utils/schema-inference'
+
+describe('ReadOnlyModelService', () => {
+    const namespace = 'books'
+    const mockSchema = MockBookSchema
+
+    let repository: MockMemoryRepository<typeof mockSchema>
+    let emitter: EventManager
+    let service: ReadOnlyModelService<typeof mockSchema>
+
+    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>[]>) => {},
+    )
+
+    beforeEach(() => {
+        repository = new MockMemoryRepository({ schema: mockSchema })
+        emitter = new EventManager()
+
+        beforeLoadSpy.mockClear()
+        afterLoadSpy.mockClear()
+        beforeLoadManySpy.mockClear()
+        afterLoadManySpy.mockClear()
+        beforeSearchSpy.mockClear()
+        afterSearchSpy.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,
+        )
+
+        service = new ReadOnlyModelService({ repository, emitter, schema: mockSchema, namespace })
+    })
+
+    it('should load a single record', async () => {
+        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+        await repository.create(input)
+
+        const record = await service.load({ id: 42 })
+
+        expect(record).toEqual(input)
+    })
+
+    it('should return null when loading a non-existent record', async () => {
+        const record = await service.load({ id: 999 })
+
+        expect(record).toBeNull()
+    })
+
+    it('should load multiple records', async () => {
+        const input1 = { id: 42, title: 'Test Book 1', author: 'Author Name 1', publishedDate: new Date() }
+        const input2 = { id: 43, title: 'Test Book 2', author: 'Author Name 2', publishedDate: new Date() }
+        await repository.create(input1)
+        await repository.create(input2)
+
+        const records = await service.loadMany([{ id: 42 }, { id: 43 }])
+
+        expect(records).toEqual([input1, input2])
+    })
+
+    it('should search for records', async () => {
+        const input1 = { id: 42, title: 'Test Book 1', author: 'Author Name 1', publishedDate: new Date() }
+        const input2 = { id: 43, title: 'Test Book 2', author: 'Author Name 2', publishedDate: new Date() }
+        await repository.create(input1)
+        await repository.create(input2)
+
+        const results = await service.search(
+            { text: 'Test' },
+            {
+                sort: [
+                    {
+                        title: 'asc',
+                    },
+                    {
+                        author: 'desc',
+                    },
+                ],
+            },
+        )
+
+        expect(results.results).toEqual([input1, input2])
+        expect(results.pagination.total).toBe(2)
+    })
+
+    it('should return empty results when searching for non-existent records', async () => {
+        const results = await service.search({ text: 'Non-existent' })
+
+        expect(results.results).toEqual([])
+        expect(results.pagination.total).toBe(0)
+    })
+
+    it('should handle pagination options correctly', async () => {
+        // Create 5 items
+        for (let i = 1; i <= 5; i++) {
+            await repository.create({
+                id: i,
+                title: `Test Book ${i}`,
+                author: `Author ${i}`,
+                publishedDate: new Date(),
+            })
+        }
+
+        // Test first page with pageSize 2
+        const page1 = await service.search(
+            {},
+            {
+                pagination: { page: 1, pageSize: 2 },
+            },
+        )
+        expect(page1.results).toHaveLength(2)
+        expect(page1.pagination.page).toBe(1)
+        expect(page1.pagination.pageSize).toBe(2)
+        expect(page1.pagination.total).toBe(5)
+        expect(page1.pagination.totalPages).toBe(3)
+
+        // Test second page
+        const page2 = await service.search(
+            {},
+            {
+                pagination: { page: 2, pageSize: 2 },
+            },
+        )
+        expect(page2.results).toHaveLength(2)
+        expect(page2.pagination.page).toBe(2)
+
+        // Test last page
+        const page3 = await service.search(
+            {},
+            {
+                pagination: { page: 3, pageSize: 2 },
+            },
+        )
+        expect(page3.results).toHaveLength(1)
+        expect(page3.pagination.page).toBe(3)
+    })
+
+    it('should handle sort options correctly', async () => {
+        const input1 = { id: 1, title: 'Z Book', author: 'Author A', publishedDate: new Date('2023-01-01') }
+        const input2 = { id: 2, title: 'A Book', author: 'Author B', publishedDate: new Date('2023-02-01') }
+        const input3 = { id: 3, title: 'M Book', author: 'Author C', publishedDate: new Date('2023-03-01') }
+
+        await repository.create(input1)
+        await repository.create(input2)
+        await repository.create(input3)
+
+        // Sort by title ascending
+        const titleAscResults = await service.search(
+            {},
+            {
+                sort: [{ title: 'asc' }],
+            },
+        )
+        expect(titleAscResults.results.map((r) => r.title)).toEqual(['A Book', 'M Book', 'Z Book'])
+
+        // Sort by title descending
+        const titleDescResults = await service.search(
+            {},
+            {
+                sort: [{ title: 'desc' }],
+            },
+        )
+        expect(titleDescResults.results.map((r) => r.title)).toEqual(['Z Book', 'M Book', 'A Book'])
+
+        // Sort by author ascending
+        const authorAscResults = await service.search(
+            {},
+            {
+                sort: [{ author: 'asc' }],
+            },
+        )
+        expect(authorAscResults.results.map((r) => r.author)).toEqual(['Author A', 'Author B', 'Author C'])
+    })
+
+    it('should handle combined filtering, sorting, and pagination', async () => {
+        const repositoryWithFilter = new MockMemoryRepository({
+            schema: mockSchema,
+            filter: (data, filters) => {
+                if (filters.text) {
+                    return data.title.toLowerCase().includes(filters.text.toLowerCase())
+                }
+                return true
+            },
+        })
+
+        const serviceWithFilter = new ReadOnlyModelService({
+            repository: repositoryWithFilter,
+            emitter,
+            namespace,
+            schema: mockSchema,
+        })
+
+        await repositoryWithFilter.create({ title: 'Test Z Book', author: 'Author 1', publishedDate: new Date() })
+        await repositoryWithFilter.create({ title: 'Test A Book', author: 'Author 2', publishedDate: new Date() })
+        await repositoryWithFilter.create({ title: 'Other Book', author: 'Author 3', publishedDate: new Date() })
+        await repositoryWithFilter.create({ title: 'Test M Book', author: 'Author 4', publishedDate: new Date() })
+
+        const results = await serviceWithFilter.search(
+            { text: 'Test' },
+            {
+                sort: [{ title: 'asc' }],
+                pagination: { page: 1, pageSize: 2 },
+            },
+        )
+
+        expect(results.results).toHaveLength(2)
+        expect(results.results.map((r) => r.title)).toEqual(['Test A Book', 'Test M Book'])
+        expect(results.pagination.total).toBe(3) // 3 "Test" books total
+        expect(results.pagination.totalPages).toBe(2)
+    })
+
+    it('should trigger before and after events for load', async () => {
+        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+        await repository.create(input)
+
+        const record = await service.load({ id: 42 })
+
+        expect(record).toEqual(input)
+        expect(beforeLoadSpy).toHaveBeenCalledTimes(1)
+        expect(beforeLoadSpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'books::book.beforeLoad' }))
+        expect(afterLoadSpy).toHaveBeenCalledTimes(1)
+        expect(afterLoadSpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'books::book.afterLoad' }))
+    })
+
+    it('should trigger before and after events for loadMany', async () => {
+        const input1 = { id: 42, title: 'Test Book 1', author: 'Author Name 1', publishedDate: new Date() }
+        const input2 = { id: 43, title: 'Test Book 2', author: 'Author Name 2', publishedDate: new Date() }
+        await repository.create(input1)
+        await repository.create(input2)
+
+        const records = await service.loadMany([{ id: 42 }, { id: 43 }])
+
+        expect(records).toEqual([input1, input2])
+        expect(beforeLoadManySpy).toHaveBeenCalledTimes(1)
+        expect(beforeLoadManySpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'books::book.beforeLoadMany' }))
+        expect(afterLoadManySpy).toHaveBeenCalledTimes(1)
+        expect(afterLoadManySpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'books::book.afterLoadMany' }))
+    })
+
+    it('should trigger before and after events for search', async () => {
+        const input1 = { id: 42, title: 'Test Book 1', author: 'Author Name 1', publishedDate: new Date() }
+        const input2 = { id: 43, title: 'Test Book 2', author: 'Author Name 2', publishedDate: new Date() }
+        await repository.create(input1)
+        await repository.create(input2)
+
+        const results = await service.search({ text: 'Test' })
+
+        expect(results.results).toEqual([input1, input2])
+        expect(results.pagination.total).toBe(2)
+        expect(beforeSearchSpy).toHaveBeenCalledTimes(1)
+        expect(beforeSearchSpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'books::book.beforeSearch' }))
+        expect(afterSearchSpy).toHaveBeenCalledTimes(1)
+        expect(afterSearchSpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'books::book.afterSearch' }))
+    })
+})