@declaro/data 2.0.0-beta.116 → 2.0.0-beta.118

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

@@ -5,6 +5,7 @@ import { MockBookSchema, type MockBookInput } from '../../test/mock/models/mock-
 import { EventManager } from '@declaro/core'
 import { mock } from 'bun:test'
 import type { InferDetail } from '../../shared/utils/schema-inference'
+import { ModelMutationAction } from '../events/event-types'
 
 describe('ModelService', () => {
     const namespace = 'books'
@@ -629,432 +630,4 @@ describe('ModelService', () => {
             expect(results).toEqual(inputs)
         })
     })
-
-    describe('normalizeInput functionality', () => {
-        class TestModelService extends ModelService<typeof mockSchema> {
-            public testNormalizeInput(input: any) {
-                return this.normalizeInput(input)
-            }
-
-            protected async normalizeInput(input: MockBookInput): Promise<MockBookInput> {
-                return {
-                    ...input,
-                    title: input.title?.trim(),
-                    author: input.author?.trim(),
-                    publishedDate: new Date('2023-01-01'),
-                }
-            }
-        }
-
-        let testService: TestModelService
-
-        beforeEach(() => {
-            testService = new TestModelService({ repository, emitter, schema: mockSchema, namespace })
-        })
-
-        it('should use default normalizeInput method (no changes) when not overridden', async () => {
-            const input = { title: '  Test Book  ', author: '  Author Name  ', publishedDate: new Date() }
-            const normalized = await service['normalizeInput'](input)
-
-            expect(normalized).toEqual(input)
-            expect(normalized).toBe(input) // Should be the exact same reference
-        })
-
-        it('should use custom normalizeInput method for create operation', async () => {
-            const input = { title: '  Test Book  ', author: '  Author Name  ', publishedDate: new Date() }
-            const createdItem = await testService.create(input)
-
-            expect(createdItem.title).toBe('Test Book')
-            expect(createdItem.author).toBe('Author Name')
-            expect(createdItem.publishedDate).toEqual(new Date('2023-01-01'))
-        })
-
-        it('should use custom normalizeInput method for update operation', async () => {
-            const input = { id: 42, title: 'Original Book', author: 'Original Author', publishedDate: new Date() }
-            const createdItem = await testService.create(input)
-
-            const updateInput = { title: '  Updated Book  ', author: '  Updated Author  ', publishedDate: new Date() }
-            const updatedItem = await testService.update({ id: createdItem.id }, updateInput)
-
-            expect(updatedItem.title).toBe('Updated Book')
-            expect(updatedItem.author).toBe('Updated Author')
-            expect(updatedItem.publishedDate).toEqual(new Date('2023-01-01'))
-        })
-
-        it('should use custom normalizeInput method for upsert operation', async () => {
-            const input = { id: 42, title: '  Test Book  ', author: '  Author Name  ', publishedDate: new Date() }
-            const upsertedItem = await testService.upsert(input)
-
-            expect(upsertedItem.title).toBe('Test Book')
-            expect(upsertedItem.author).toBe('Author Name')
-            expect(upsertedItem.publishedDate).toEqual(new Date('2023-01-01'))
-
-            // Upsert again with different data
-            const updateInput = {
-                id: 42,
-                title: '  Updated Book  ',
-                author: '  Updated Author  ',
-                publishedDate: new Date(),
-            }
-            const updatedItem = await testService.upsert(updateInput)
-
-            expect(updatedItem.title).toBe('Updated Book')
-            expect(updatedItem.author).toBe('Updated Author')
-            expect(updatedItem.publishedDate).toEqual(new Date('2023-01-01'))
-        })
-
-        it('should use custom normalizeInput method for bulkUpsert operation', async () => {
-            const inputs = [
-                { id: 1, title: '  Book One  ', author: '  Author One  ', publishedDate: new Date() },
-                { id: 2, title: '  Book Two  ', author: '  Author Two  ', publishedDate: new Date() },
-                { title: '  Book Three  ', author: '  Author Three  ', publishedDate: new Date() }, // No ID - will be created
-            ]
-
-            const results = await testService.bulkUpsert(inputs)
-
-            expect(results).toHaveLength(3)
-            expect(results[0].title).toBe('Book One')
-            expect(results[0].author).toBe('Author One')
-            expect(results[0].publishedDate).toEqual(new Date('2023-01-01'))
-
-            expect(results[1].title).toBe('Book Two')
-            expect(results[1].author).toBe('Author Two')
-            expect(results[1].publishedDate).toEqual(new Date('2023-01-01'))
-
-            expect(results[2].title).toBe('Book Three')
-            expect(results[2].author).toBe('Author Three')
-            expect(results[2].publishedDate).toEqual(new Date('2023-01-01'))
-        })
-
-        it('should preserve events order with normalized input in create operation', async () => {
-            const input = { title: '  Test Book  ', author: '  Author Name  ', publishedDate: new Date() }
-            await testService.create(input)
-
-            // Debug: Let's see what was actually called
-            const beforeCreateCall = beforeCreateSpy.mock.calls[0][0]
-            const afterCreateCall = afterCreateSpy.mock.calls[0][0]
-
-            expect(beforeCreateCall.meta.input.title).toBe('Test Book')
-            expect(beforeCreateCall.meta.input.author).toBe('Author Name')
-            expect(beforeCreateCall.meta.input.publishedDate).toEqual(new Date('2023-01-01'))
-
-            expect(afterCreateCall.meta.input.title).toBe('Test Book')
-            expect(afterCreateCall.meta.input.author).toBe('Author Name')
-            expect(afterCreateCall.meta.input.publishedDate).toEqual(new Date('2023-01-01'))
-        })
-
-        it('should call normalizeInput method exactly once per input during bulkUpsert with Promise.all', async () => {
-            const normalizeInputSpy = mock(async (input: any) => ({ ...input, normalized: true }))
-
-            class SpyService extends ModelService<typeof mockSchema> {
-                protected async normalizeInput(input: any) {
-                    return normalizeInputSpy(input)
-                }
-            }
-
-            const spyService = new SpyService({ repository, emitter, schema: mockSchema, namespace })
-
-            const inputs = [
-                { id: 1, title: 'Book One', author: 'Author One', publishedDate: new Date() },
-                { id: 2, title: 'Book Two', author: 'Author Two', publishedDate: new Date() },
-            ]
-
-            await spyService.bulkUpsert(inputs)
-
-            expect(normalizeInputSpy).toHaveBeenCalledTimes(2)
-            expect(normalizeInputSpy).toHaveBeenNthCalledWith(1, inputs[0])
-            expect(normalizeInputSpy).toHaveBeenNthCalledWith(2, inputs[1])
-        })
-
-        it('should handle async normalization errors gracefully', async () => {
-            class ErrorNormalizationService extends ModelService<typeof mockSchema> {
-                protected async normalizeInput(input: any) {
-                    if (input.title === 'ERROR') {
-                        throw new Error('Normalization failed')
-                    }
-                    return input
-                }
-            }
-
-            const errorService = new ErrorNormalizationService({
-                repository,
-                emitter,
-                schema: mockSchema,
-                namespace,
-            })
-
-            const input = { title: 'ERROR', author: 'Author Name', publishedDate: new Date() }
-
-            await expect(errorService.create(input)).rejects.toThrow('Normalization failed')
-        })
-
-        it('should process bulk normalization in parallel for performance', async () => {
-            const processingTimes: number[] = []
-
-            class TimingNormalizationService extends ModelService<typeof mockSchema> {
-                protected async normalizeInput(input: any) {
-                    const start = Date.now()
-                    // Simulate some async work
-                    await new Promise((resolve) => setTimeout(resolve, 50))
-                    processingTimes.push(Date.now() - start)
-                    return input
-                }
-            }
-
-            const timingService = new TimingNormalizationService({
-                repository,
-                emitter,
-                schema: mockSchema,
-                namespace,
-            })
-
-            const inputs = [
-                { id: 1, title: 'Book One', author: 'Author One', publishedDate: new Date() },
-                { id: 2, title: 'Book Two', author: 'Author Two', publishedDate: new Date() },
-                { id: 3, title: 'Book Three', author: 'Author Three', publishedDate: new Date() },
-            ]
-
-            const start = Date.now()
-            await timingService.bulkUpsert(inputs)
-            const totalTime = Date.now() - start
-
-            // With Promise.all, total time should be closer to single operation time rather than sum of all
-            // Allow some variance for test stability
-            expect(totalTime).toBeLessThan(150) // Much less than 3 * 50ms = 150ms
-            expect(processingTimes).toHaveLength(3)
-        })
-    })
-
-    describe('Response Normalization', () => {
-        class TestRepository extends MockMemoryRepository<typeof mockSchema> {
-            constructor() {
-                super({
-                    schema: mockSchema,
-                })
-            }
-
-            async create(input: MockBookInput): Promise<any> {
-                const record = await super.create(input)
-                // Return with publishedDate as string to test normalization
-                record.publishedDate = '2024-01-01' as any
-                return record
-            }
-
-            async update(lookup: any, input: MockBookInput): Promise<any> {
-                const record = await super.update(lookup, input)
-                // Return with publishedDate as string to test normalization
-                record.publishedDate = '2024-01-01' as any
-                return record
-            }
-
-            async upsert(input: MockBookInput): Promise<any> {
-                const record = await super.upsert(input)
-                // Return with publishedDate as string to test normalization
-                record.publishedDate = '2024-01-01' as any
-                return record
-            }
-
-            async bulkUpsert(inputs: MockBookInput[]): Promise<any[]> {
-                const records = await super.bulkUpsert(inputs)
-                // Return with publishedDate as string to test normalization
-                for (const record of records) {
-                    record.publishedDate = '2024-01-01' as any
-                }
-                return records
-            }
-
-            async remove(lookup: any): Promise<any> {
-                const record = await super.remove(lookup)
-                // Return with publishedDate as string to test normalization
-                if (record) {
-                    record.publishedDate = '2024-01-01' as any
-                }
-                return record
-            }
-
-            async restore(lookup: any): Promise<any> {
-                const record = await super.restore(lookup)
-                // Return with publishedDate as string to test normalization
-                if (record) {
-                    record.publishedDate = '2024-01-01' as any
-                }
-                return record
-            }
-        }
-
-        class TestServiceWithNormalization extends ModelService<typeof mockSchema> {
-            async normalizeDetail(detail: InferDetail<typeof mockSchema>): Promise<InferDetail<typeof mockSchema>> {
-                // Handle null case (e.g., when load returns null)
-                if (!detail) return detail
-
-                // Convert string dates back to Date objects
-                if (typeof detail.publishedDate === 'string') {
-                    detail.publishedDate = new Date(detail.publishedDate) as any
-                }
-                return detail
-            }
-
-            async normalizeSummary(summary: InferDetail<typeof mockSchema>): Promise<InferDetail<typeof mockSchema>> {
-                // Handle null case (e.g., when load returns null)
-                if (!summary) return summary
-
-                // Convert string dates back to Date objects
-                if (typeof summary.publishedDate === 'string') {
-                    summary.publishedDate = new Date(summary.publishedDate) as any
-                }
-                return summary
-            }
-        }
-
-        let testRepository: TestRepository
-        let testService: TestServiceWithNormalization
-
-        beforeEach(() => {
-            testRepository = new TestRepository()
-            emitter = new EventManager()
-
-            testService = new TestServiceWithNormalization({
-                repository: testRepository,
-                emitter,
-                schema: mockSchema,
-                namespace,
-            })
-        })
-
-        it('should allow custom normalization of details in the create response when overridden', async () => {
-            const input = { id: 200, title: 'Create Test', author: 'Creator', publishedDate: new Date() }
-            const record = await testService.create(input)
-
-            const expectedDate = new Date('2024-01-01')
-            const actualDate = record.publishedDate
-
-            expect(actualDate).toEqual(expectedDate)
-            expect(actualDate).toBeInstanceOf(Date)
-        })
-
-        it('should allow custom normalization of details in the update response when overridden', async () => {
-            const input = { id: 201, title: 'Update Test', author: 'Updater', publishedDate: new Date() }
-            await testRepository.create(input)
-
-            const updatedInput = { title: 'Updated Test', author: 'Updated Author', publishedDate: new Date() }
-            const record = await testService.update({ id: 201 }, updatedInput)
-
-            const expectedDate = new Date('2024-01-01')
-            const actualDate = record.publishedDate
-
-            expect(actualDate).toEqual(expectedDate)
-            expect(actualDate).toBeInstanceOf(Date)
-        })
-
-        it('should allow custom normalization of details in the upsert response when creating and overridden', async () => {
-            const input = { id: 202, title: 'Upsert Create Test', author: 'Upserter', publishedDate: new Date() }
-            const record = await testService.upsert(input)
-
-            const expectedDate = new Date('2024-01-01')
-            const actualDate = record.publishedDate
-
-            expect(actualDate).toEqual(expectedDate)
-            expect(actualDate).toBeInstanceOf(Date)
-        })
-
-        it('should allow custom normalization of details in the upsert response when updating and overridden', async () => {
-            const input = { id: 203, title: 'Upsert Update Test', author: 'Upserter', publishedDate: new Date() }
-            await testRepository.create(input)
-
-            const updatedInput = {
-                id: 203,
-                title: 'Updated Upsert Test',
-                author: 'Updated Upserter',
-                publishedDate: new Date(),
-            }
-            const record = await testService.upsert(updatedInput)
-
-            const expectedDate = new Date('2024-01-01')
-            const actualDate = record.publishedDate
-
-            expect(actualDate).toEqual(expectedDate)
-            expect(actualDate).toBeInstanceOf(Date)
-        })
-
-        it('should allow custom normalization of details in the bulkUpsert response when overridden', async () => {
-            const input1 = { id: 204, title: 'Bulk Test 1', author: 'Bulk Author 1', publishedDate: new Date() }
-            const input2 = { id: 205, title: 'Bulk Test 2', author: 'Bulk Author 2', publishedDate: new Date() }
-
-            const records = await testService.bulkUpsert([input1, input2])
-
-            const expectedDate = new Date('2024-01-01')
-
-            for (const record of records) {
-                const actualDate = record.publishedDate
-                expect(actualDate).toEqual(expectedDate)
-                expect(actualDate).toBeInstanceOf(Date)
-            }
-        })
-
-        it('should allow custom normalization of details in the bulkUpsert response with mixed create and update when overridden', async () => {
-            const existingInput = { id: 206, title: 'Existing', author: 'Existing Author', publishedDate: new Date() }
-            await testRepository.create(existingInput)
-
-            const updateInput = {
-                id: 206,
-                title: 'Updated Existing',
-                author: 'Updated Author',
-                publishedDate: new Date(),
-            }
-            const createInput = { id: 207, title: 'New Record', author: 'New Author', publishedDate: new Date() }
-
-            const records = await testService.bulkUpsert([updateInput, createInput])
-
-            const expectedDate = new Date('2024-01-01')
-
-            for (const record of records) {
-                const actualDate = record.publishedDate
-                expect(actualDate).toEqual(expectedDate)
-                expect(actualDate).toBeInstanceOf(Date)
-            }
-        })
-
-        it('should allow custom normalization of summaries in the remove response when overridden', async () => {
-            const input = { id: 208, title: 'Remove Test', author: 'Remover', publishedDate: new Date() }
-            await testRepository.create(input)
-
-            const record = await testService.remove({ id: 208 })
-
-            const expectedDate = new Date('2024-01-01')
-            const actualDate = record.publishedDate
-
-            expect(actualDate).toEqual(expectedDate)
-            expect(actualDate).toBeInstanceOf(Date)
-        })
-
-        it('should allow custom normalization of summaries in the restore response when overridden', async () => {
-            const input = { id: 209, title: 'Restore Test', author: 'Restorer', publishedDate: new Date() }
-            await testRepository.create(input)
-            await testRepository.remove({ id: 209 })
-
-            const record = await testService.restore({ id: 209 })
-
-            const expectedDate = new Date('2024-01-01')
-            const actualDate = record.publishedDate
-
-            expect(actualDate).toEqual(expectedDate)
-            expect(actualDate).toBeInstanceOf(Date)
-        })
-
-        it('should not normalize data by default when normalization methods are not overridden', async () => {
-            const defaultService = new ModelService({
-                repository: testRepository,
-                emitter,
-                schema: mockSchema,
-                namespace,
-            })
-
-            const input = { id: 210, title: 'Default Test', author: 'Default Author', publishedDate: new Date() }
-            const record = await defaultService.create(input)
-
-            // Should return the raw string from repository since no normalization is applied
-            expect(record.publishedDate as any).toBe('2024-01-01')
-            expect(typeof record.publishedDate).toBe('string')
-        })
-    })
 })