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

package/dist/ts/domain/services/read-only-model-service.d.ts

@@ -9,6 +9,23 @@ export interface ISearchOptions<TSchema extends AnyModelSchema> extends IActionO
     sort?: InferSort<TSchema>;
 }
 export declare class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseModelService<TSchema> {
+    /**
+     * Normalize the detail data to match the expected schema.
+     * WARNING: This method is called once per detail in load operations.
+     * Any intensive operations or queries should be avoided here, and done via bulk operations in the respective methods such as `loadMany` instead.
+     * @param detail The detail data to normalize.
+     * @returns The normalized detail data.
+     */
+    normalizeDetail(detail: InferDetail<TSchema>): Promise<InferDetail<TSchema>>;
+    /**
+     * Normalize the summary data to match the expected schema.
+     * WARNING: This method is called once per summary in search results, often in parallel.
+     * Any intensive operations or queries should be avoided here, and done via bulk operations in the respective methods such as `search` instead.
+     *
+     * @param summary The summary data to normalize.
+     * @returns The normalized summary data.
+     */
+    normalizeSummary(summary: InferDetail<TSchema>): Promise<InferDetail<TSchema>>;
     /**
      * Load a single record by its lookup criteria.
      * @param lookup The lookup criteria to find the record.

package/dist/ts/domain/services/read-only-model-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-only-model-service.d.ts","sourceRoot":"","sources":["../../../../src/domain/services/read-only-model-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EACR,WAAW,EACX,YAAY,EACZ,WAAW,EACX,kBAAkB,EAClB,SAAS,EACZ,MAAM,qCAAqC,CAAA;AAG5C,OAAO,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAG5D,MAAM,WAAW,YAAa,SAAQ,cAAc;CAAG;AACvD,MAAM,WAAW,cAAc,CAAC,OAAO,SAAS,cAAc,CAAE,SAAQ,cAAc;IAClF,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAC7B,IAAI,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;CAC5B;AAED,qBAAa,oBAAoB,CAAC,OAAO,SAAS,cAAc,CAAE,SAAQ,gBAAgB,CAAC,OAAO,CAAC;IAC/F;;;;;OAKG;IACG,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAqB/F;;;;;OAKG;IACG,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAqBxG;;;;;OAKG;IACG,MAAM,CACR,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,GAClC,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAsBvC;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAqBlG"}
+{"version":3,"file":"read-only-model-service.d.ts","sourceRoot":"","sources":["../../../../src/domain/services/read-only-model-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAS,MAAM,eAAe,CAAA;AAC1D,OAAO,KAAK,EACR,WAAW,EACX,YAAY,EACZ,WAAW,EACX,kBAAkB,EAClB,SAAS,EACZ,MAAM,qCAAqC,CAAA;AAG5C,OAAO,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAG5D,MAAM,WAAW,YAAa,SAAQ,cAAc;CAAG;AACvD,MAAM,WAAW,cAAc,CAAC,OAAO,SAAS,cAAc,CAAE,SAAQ,cAAc;IAClF,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAC7B,IAAI,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;CAC5B;AAED,qBAAa,oBAAoB,CAAC,OAAO,SAAS,cAAc,CAAE,SAAQ,gBAAgB,CAAC,OAAO,CAAC;IAC/F;;;;;;OAMG;IACG,eAAe,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAalF;;;;;;;OAOG;IACG,gBAAgB,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAapF;;;;;OAKG;IACG,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAqB/F;;;;;OAKG;IACG,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAqBxG;;;;;OAKG;IACG,MAAM,CACR,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,GAClC,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAyBvC;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAqBlG"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@declaro/data",
-    "version": "2.0.0-beta.110",
+    "version": "2.0.0-beta.111",
     "description": "A data-mapper framework for managing application data across integrated systems.",
     "main": "dist/node/index.cjs",
     "module": "dist/node/index.js",
@@ -22,9 +22,9 @@
         "@declaro/zod": "^2.0.0-beta.51"
     },
     "devDependencies": {
-        "@declaro/auth": "^2.0.0-beta.110",
-        "@declaro/core": "^2.0.0-beta.110",
-        "@declaro/zod": "^2.0.0-beta.110",
+        "@declaro/auth": "^2.0.0-beta.111",
+        "@declaro/core": "^2.0.0-beta.111",
+        "@declaro/zod": "^2.0.0-beta.111",
         "crypto-browserify": "^3.12.1",
         "typescript": "^5.8.3",
         "uuid": "^11.1.0",
@@ -43,5 +43,5 @@
         "require": "./dist/node/index.cjs",
         "browser": "./dist/browser/index.js"
     },
-    "gitHead": "3cae222af9b009c585bb824012814b9ca3e62638"
+    "gitHead": "a4506956d649e65c945a96482df1156be7510d85"
 }

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

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach } from 'bun:test'
 import { ModelService } from './model-service'
 import { MockMemoryRepository } from '../../test/mock/repositories/mock-memory-repository'
-import { MockBookSchema } from '../../test/mock/models/mock-book-models'
+import { MockBookSchema, type MockBookInput } from '../../test/mock/models/mock-book-models'
 import { EventManager } from '@declaro/core'
 import { mock } from 'bun:test'
 
@@ -635,12 +635,12 @@ describe('ModelService', () => {
                 return this.normalizeInput(input)
             }
 
-            protected async normalizeInput(input: any) {
+            protected async normalizeInput(input: MockBookInput): Promise<MockBookInput> {
                 return {
                     ...input,
                     title: input.title?.trim(),
                     author: input.author?.trim(),
-                    normalizedAt: new Date('2023-01-01'),
+                    publishedDate: new Date('2023-01-01'),
                 }
             }
         }
@@ -665,7 +665,7 @@ describe('ModelService', () => {
 
             expect(createdItem.title).toBe('Test Book')
             expect(createdItem.author).toBe('Author Name')
-            expect((createdItem as any).normalizedAt).toEqual(new Date('2023-01-01'))
+            expect(createdItem.publishedDate).toEqual(new Date('2023-01-01'))
         })
 
         it('should use custom normalizeInput method for update operation', async () => {
@@ -677,7 +677,7 @@ describe('ModelService', () => {
 
             expect(updatedItem.title).toBe('Updated Book')
             expect(updatedItem.author).toBe('Updated Author')
-            expect((updatedItem as any).normalizedAt).toEqual(new Date('2023-01-01'))
+            expect(updatedItem.publishedDate).toEqual(new Date('2023-01-01'))
         })
 
         it('should use custom normalizeInput method for upsert operation', async () => {
@@ -686,7 +686,7 @@ describe('ModelService', () => {
 
             expect(upsertedItem.title).toBe('Test Book')
             expect(upsertedItem.author).toBe('Author Name')
-            expect((upsertedItem as any).normalizedAt).toEqual(new Date('2023-01-01'))
+            expect(upsertedItem.publishedDate).toEqual(new Date('2023-01-01'))
 
             // Upsert again with different data
             const updateInput = {
@@ -699,7 +699,7 @@ describe('ModelService', () => {
 
             expect(updatedItem.title).toBe('Updated Book')
             expect(updatedItem.author).toBe('Updated Author')
-            expect((updatedItem as any).normalizedAt).toEqual(new Date('2023-01-01'))
+            expect(updatedItem.publishedDate).toEqual(new Date('2023-01-01'))
         })
 
         it('should use custom normalizeInput method for bulkUpsert operation', async () => {
@@ -714,15 +714,15 @@ describe('ModelService', () => {
             expect(results).toHaveLength(3)
             expect(results[0].title).toBe('Book One')
             expect(results[0].author).toBe('Author One')
-            expect((results[0] as any).normalizedAt).toEqual(new Date('2023-01-01'))
+            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] as any).normalizedAt).toEqual(new Date('2023-01-01'))
+            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] as any).normalizedAt).toEqual(new Date('2023-01-01'))
+            expect(results[2].publishedDate).toEqual(new Date('2023-01-01'))
         })
 
         it('should preserve events order with normalized input in create operation', async () => {
@@ -735,61 +735,11 @@ describe('ModelService', () => {
 
             expect(beforeCreateCall.meta.input.title).toBe('Test Book')
             expect(beforeCreateCall.meta.input.author).toBe('Author Name')
-            expect(beforeCreateCall.meta.input.normalizedAt).toEqual(new Date('2023-01-01'))
+            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.normalizedAt).toEqual(new Date('2023-01-01'))
-        })
-
-        it('should handle complex async normalization logic', async () => {
-            class ComplexNormalizationService extends ModelService<typeof mockSchema> {
-                protected async normalizeInput(input: any) {
-                    // Simulate async operations like database lookups, API calls, etc.
-                    await new Promise((resolve) => setTimeout(resolve, 10))
-
-                    const normalized = { ...input }
-
-                    // Complex normalization logic
-                    if (normalized.title) {
-                        normalized.title = normalized.title
-                            .trim()
-                            .replace(/\s+/g, ' ')
-                            .toLowerCase()
-                            .replace(/\b\w/g, (l: string) => l.toUpperCase()) // Title case
-                    }
-
-                    if (normalized.author) {
-                        normalized.author = normalized.author.trim()
-                    }
-
-                    // Add metadata
-                    normalized.processedAt = new Date('2023-01-01')
-                    normalized.version = (normalized.version || 0) + 1
-
-                    return normalized
-                }
-            }
-
-            const complexService = new ComplexNormalizationService({
-                repository,
-                emitter,
-                schema: mockSchema,
-                namespace,
-            })
-
-            const input = {
-                title: '  the  great   book  ',
-                author: '  John Doe  ',
-                publishedDate: new Date(),
-            }
-
-            const result = await complexService.create(input)
-
-            expect(result.title).toBe('The Great Book')
-            expect(result.author).toBe('John Doe')
-            expect((result as any).processedAt).toEqual(new Date('2023-01-01'))
-            expect((result as any).version).toBe(1)
+            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 () => {
@@ -873,4 +823,199 @@ describe('ModelService', () => {
             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 TestService extends ModelService<typeof mockSchema> {}
+
+        let testRepository: TestRepository
+        let testService: TestService
+
+        beforeEach(() => {
+            testRepository = new TestRepository()
+            emitter = new EventManager()
+
+            testService = new TestService({
+                repository: testRepository,
+                emitter,
+                schema: mockSchema,
+                namespace,
+            })
+        })
+
+        it('should normalize details in the create response', 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 normalize details in the update response', 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 normalize details in the upsert response when creating', 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 normalize details in the upsert response when updating', 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 normalize details in the bulkUpsert response', 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 normalize details in the bulkUpsert response with mixed create and update', 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 normalize summaries in the remove response', 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 normalize summaries in the restore response', 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)
+        })
+    })
 })

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

@@ -49,7 +49,7 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         await this.emitter.emitAsync(afterRemoveEvent)
 
         // Return the results of the removal
-        return result
+        return await this.normalizeSummary(result)
     }
 
     /**
@@ -77,7 +77,7 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         await this.emitter.emitAsync(afterRestoreEvent)
 
         // Return the results of the restore operation
-        return result
+        return await this.normalizeSummary(result)
     }
 
     async create(input: InferInput<TSchema>, options?: ICreateOptions): Promise<InferDetail<TSchema>> {
@@ -102,7 +102,7 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         await this.emitter.emitAsync(afterCreateEvent)
 
         // Return the results of the creation
-        return result
+        return await this.normalizeDetail(result)
     }
 
     async update(
@@ -131,7 +131,7 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         await this.emitter.emitAsync(afterUpdateEvent)
 
         // Return the results of the update
-        return result
+        return await this.normalizeDetail(result)
     }
 
     /**
@@ -187,7 +187,7 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         await this.emitter.emitAsync(afterUpsertEvent)
 
         // Return the results of the upsert operation
-        return result
+        return await this.normalizeDetail(result)
     }
 
     /**
@@ -340,6 +340,6 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)))
 
         // Return the results
-        return results
+        return await Promise.all(results.map((result) => this.normalizeDetail(result)))
     }
 }

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

@@ -1,7 +1,7 @@
-import { describe, it, expect, beforeEach, spyOn, mock } from 'bun:test'
-import { ReadOnlyModelService } from './read-only-model-service'
+import { describe, it, expect, beforeEach, spyOn, mock, beforeAll } from 'bun:test'
+import { ReadOnlyModelService, type ILoadOptions } from './read-only-model-service'
 import { MockMemoryRepository } from '../../test/mock/repositories/mock-memory-repository'
-import { MockBookSchema } from '../../test/mock/models/mock-book-models'
+import { MockBookSchema, type MockBookDetail, type MockBookLookup } 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'
@@ -293,4 +293,104 @@ describe('ReadOnlyModelService', () => {
         expect(afterSearchSpy).toHaveBeenCalledTimes(1)
         expect(afterSearchSpy).toHaveBeenCalledWith(expect.objectContaining({ type: 'books::book.afterSearch' }))
     })
+
+    describe('Response Normalization', () => {
+        class TestRepository extends MockMemoryRepository<typeof mockSchema> {
+            constructor() {
+                super({
+                    schema: mockSchema,
+                })
+            }
+
+            async load(input: MockBookLookup): Promise<MockBookDetail | null> {
+                const record = await super.load(input)
+
+                if (record) {
+                    record.publishedDate = '2024-01-01' as any
+                }
+
+                return record
+            }
+
+            async loadMany(inputs: MockBookLookup[]): Promise<MockBookDetail[]> {
+                const records = await super.loadMany(inputs)
+
+                for (const record of records) {
+                    record.publishedDate = '2024-01-01' as any
+                }
+
+                return records
+            }
+
+            async search(
+                filters: InferFilters<typeof mockSchema>,
+                options?: ILoadOptions,
+            ): Promise<InferSearchResults<typeof mockSchema>> {
+                const results = await super.search(filters, options)
+
+                for (const record of results.results) {
+                    record.publishedDate = '2024-01-01' as any
+                }
+
+                return results
+            }
+        }
+        class TestService extends ReadOnlyModelService<typeof mockSchema> {}
+
+        let testService: TestService
+
+        beforeEach(() => {
+            repository = new TestRepository()
+            emitter = new EventManager()
+
+            testService = new TestService({ repository, emitter, schema: mockSchema, namespace })
+        })
+
+        it('should normalize details in the load response', async () => {
+            const input = { id: 100, title: 'Normalization Test', author: 'Normalizer', publishedDate: new Date() }
+            await repository.create(input)
+
+            const record = await testService.load({ id: 100 })
+
+            const expectedDate = new Date('2024-01-01')
+            const actualDate = record.publishedDate
+
+            expect(actualDate).toEqual(expectedDate)
+            expect(actualDate).toBeInstanceOf(Date)
+        })
+
+        it('should normalize details in the loadMany response', async () => {
+            const input1 = { id: 101, title: 'Normalization Test 1', author: 'Normalizer 1', publishedDate: new Date() }
+            const input2 = { id: 102, title: 'Normalization Test 2', author: 'Normalizer 2', publishedDate: new Date() }
+            await repository.create(input1)
+            await repository.create(input2)
+
+            const records = await testService.loadMany([{ id: 101 }, { id: 102 }])
+
+            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 normalize details in the search response', async () => {
+            const input1 = { id: 103, title: 'Normalization Test 3', author: 'Normalizer 3', publishedDate: new Date() }
+            const input2 = { id: 104, title: 'Normalization Test 4', author: 'Normalizer 4', publishedDate: new Date() }
+            await repository.create(input1)
+            await repository.create(input2)
+
+            const results = await testService.search({ text: 'Normalization' })
+
+            const expectedDate = new Date('2024-01-01')
+
+            for (const record of results.results) {
+                const actualDate = record.publishedDate
+                expect(actualDate).toEqual(expectedDate)
+                expect(actualDate).toBeInstanceOf(Date)
+            }
+        })
+    })
 })

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

@@ -1,4 +1,4 @@
-import type { AnyModelSchema } from '@declaro/core'
+import type { AnyModelSchema, Model } from '@declaro/core'
 import type {
     InferDetail,
     InferFilters,
@@ -19,6 +19,47 @@ export interface ISearchOptions<TSchema extends AnyModelSchema> extends IActionO
 }
 
 export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseModelService<TSchema> {
+    /**
+     * Normalize the detail data to match the expected schema.
+     * WARNING: This method is called once per detail in load operations.
+     * Any intensive operations or queries should be avoided here, and done via bulk operations in the respective methods such as `loadMany` instead.
+     * @param detail The detail data to normalize.
+     * @returns The normalized detail data.
+     */
+    async normalizeDetail(detail: InferDetail<TSchema>): Promise<InferDetail<TSchema>> {
+        const detailModel = this.schema.definition.detail as Model<any, any>
+        if (detailModel) {
+            const validation = await detailModel.validate(detail, { strict: false })
+            if (validation.issues) {
+                console.warn(`${detailModel.labels.singularLabel} shape did not match the expected schema`)
+            } else {
+                return validation.value
+            }
+        }
+        return detail
+    }
+
+    /**
+     * Normalize the summary data to match the expected schema.
+     * WARNING: This method is called once per summary in search results, often in parallel.
+     * Any intensive operations or queries should be avoided here, and done via bulk operations in the respective methods such as `search` instead.
+     *
+     * @param summary The summary data to normalize.
+     * @returns The normalized summary data.
+     */
+    async normalizeSummary(summary: InferDetail<TSchema>): Promise<InferDetail<TSchema>> {
+        const summaryModel = this.schema.definition.summary as Model<any, any>
+        if (summaryModel) {
+            const validation = await summaryModel.validate(summary, { strict: false })
+            if (validation.issues) {
+                console.warn(`${summaryModel.labels.singularLabel} shape did not match the expected schema`)
+            } else {
+                return validation.value
+            }
+        }
+        return summary
+    }
+
     /**
      * Load a single record by its lookup criteria.
      * @param lookup The lookup criteria to find the record.
@@ -43,7 +84,7 @@ export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseMo
         ).setResult(details)
         await this.emitter.emitAsync(afterLoadEvent)
 
-        return details
+        return await this.normalizeDetail(details)
     }
 
     /**
@@ -70,7 +111,7 @@ export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseMo
         ).setResult(details)
         await this.emitter.emitAsync(afterLoadManyEvent)
 
-        return details
+        return await Promise.all(details.map((detail) => this.normalizeDetail(detail)))
     }
 
     /**
@@ -101,7 +142,10 @@ export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseMo
         await this.emitter.emitAsync(afterSearchEvent)
 
         // Return the search results
-        return results
+        return {
+            ...results,
+            results: await Promise.all(results.results.map((detail) => this.normalizeSummary(detail))),
+        }
     }
 
     /**

package/dist/ts/test/domain/services/model-service.test.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=model-service.test.d.ts.map

package/dist/ts/test/domain/services/model-service.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-service.test.d.ts","sourceRoot":"","sources":["../../../../../src/test/domain/services/model-service.test.ts"],"names":[],"mappings":""}