@declaro/data 2.0.0-beta.12 → 2.0.0-beta.120

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

@@ -0,0 +1,432 @@
+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, 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'
+
+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' }))
+    })
+
+    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 TestServiceWithNormalization extends ReadOnlyModelService<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 testService: TestServiceWithNormalization
+
+        beforeEach(() => {
+            repository = new TestRepository()
+            emitter = new EventManager()
+
+            testService = new TestServiceWithNormalization({ repository, emitter, schema: mockSchema, namespace })
+        })
+
+        it('should allow custom normalization of details in the load response when overridden', 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 allow custom normalization of details in the loadMany response when overridden', 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 allow custom normalization of summaries in the search response when overridden', 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)
+            }
+        })
+
+        it('should not normalize data by default when normalization methods are not overridden', async () => {
+            const defaultService = new ReadOnlyModelService({ repository, emitter, schema: mockSchema, namespace })
+
+            const input = { id: 105, title: 'Default Test', author: 'Default Author', publishedDate: new Date() }
+            await repository.create(input)
+
+            const record = await defaultService.load({ id: 105 })
+
+            // 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')
+        })
+    })
+})

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

@@ -0,0 +1,158 @@
+import type { AnyModelSchema, Model } from '@declaro/core'
+import type {
+    InferDetail,
+    InferFilters,
+    InferLookup,
+    InferSearchResults,
+    InferSort,
+} from '../../shared/utils/schema-inference'
+import { ModelQueryEvent } from '../events/event-types'
+import { QueryEvent } from '../events/query-event'
+import { BaseModelService, type IActionOptions } from './base-model-service'
+import type { IPaginationInput } from '../models/pagination'
+
+export interface ILoadOptions extends IActionOptions {}
+export interface ISearchOptions<TSchema extends AnyModelSchema> extends IActionOptions {
+    pagination?: IPaginationInput
+    sort?: InferSort<TSchema>
+}
+
+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>> {
+        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>> {
+        return summary
+    }
+
+    /**
+     * Load a single record by its lookup criteria.
+     * @param lookup The lookup criteria to find the record.
+     * @param options Additional options for the load operation.
+     * @returns The loaded record details.
+     */
+    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)
+
+        // Load the details from the repository
+        const details = await this.repository.load(lookup)
+
+        // 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)
+
+        return await this.normalizeDetail(details)
+    }
+
+    /**
+     * Load multiple records by their lookup criteria.
+     * @param lookups The lookup criteria to find the records.
+     * @param options Additional options for the load operation.
+     * @returns An array of loaded record details.
+     */
+    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)
+
+        // Load the details from the repository
+        const details = await this.repository.loadMany(lookups)
+
+        // 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)
+
+        return await Promise.all(details.map((detail) => this.normalizeDetail(detail)))
+    }
+
+    /**
+     * Search for records matching the given filters.
+     * @param filters The filters to apply to the search.
+     * @param options Additional options for the search operation.
+     * @returns The search results.
+     */
+    async search(
+        filters: InferFilters<TSchema>,
+        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)
+
+        // 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)
+
+        // Return the search results
+        return {
+            ...results,
+            results: await Promise.all(results.results.map((detail) => this.normalizeSummary(detail))),
+        }
+    }
+
+    /**
+     * Count the number of records matching the given filters.
+     * @param filters The filters to apply to the count operation.
+     * @returns The count of matching records.
+     */
+    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)
+
+        // 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)
+
+        // Return the count
+        return count
+    }
+}

package/src/index.ts

@@ -1,4 +1,17 @@
-export * from './databaseConnection'
-export * from './serverConnection'
-export * from './datastoreAbstract'
-export * from './hydrateEntity'
+export * from './application/model-controller'
+export * from './application/read-only-model-controller'
+export * from './domain/events/domain-event'
+export * from './domain/events/event-types'
+export * from './domain/events/mutation-event'
+export * from './domain/events/query-event'
+export * from './domain/events/request-event'
+export * from './domain/interfaces/repository'
+export * from './domain/models/pagination'
+export * from './domain/services/base-model-service'
+export * from './domain/services/model-service'
+export * from './domain/services/model-service-args'
+export * from './domain/services/read-only-model-service'
+export * from './shared/utils/schema-inference'
+export * from './shared/utils/schema-inheritance'
+export * from './test/mock/models/mock-book-models'
+export * from './test/mock/repositories/mock-memory-repository'

package/src/shared/utils/schema-inference.ts

@@ -0,0 +1,26 @@
+import type { AnyModelSchema, InferModelInput, InferModelOutput } from '@declaro/core'
+import type { IPagination } from '../../domain/models/pagination'
+
+export interface ISearchResults<T> {
+    results: T[]
+    pagination: IPagination
+}
+
+export type InferLookup<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['lookup']>
+export type InferDetail<TSchema extends AnyModelSchema> = InferModelOutput<TSchema['definition']['detail']>
+export type InferFilters<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['filters']>
+export type InferSummary<TSchema extends AnyModelSchema> = InferModelOutput<TSchema['definition']['summary']>
+export type InferSort<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['sort']>
+export type InferInput<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['input']>
+export type InferSearchResults<TSchema extends AnyModelSchema> = ISearchResults<InferSummary<TSchema>>
+export type InferEntityMetadata<TSchema extends AnyModelSchema> = ReturnType<TSchema['getEntityMetadata']>
+export type InferPrimaryKeyType<TSchema extends AnyModelSchema> =
+    InferLookup<TSchema>[InferEntityMetadata<TSchema>['primaryKey']]
+
+export type InferSummarySchema<TSchema extends AnyModelSchema> = TSchema['definition']['summary']['schema']
+export type InferDetailSchema<TSchema extends AnyModelSchema> = TSchema['definition']['detail']['schema']
+export type InferLookupSchema<TSchema extends AnyModelSchema> = TSchema['definition']['lookup']['schema']
+export type InferInputSchema<TSchema extends AnyModelSchema> = TSchema['definition']['input']['schema']
+export type InferFiltersSchema<TSchema extends AnyModelSchema> = TSchema['definition']['filters']['schema']
+export type InferSortSchema<TSchema extends AnyModelSchema> = TSchema['definition']['sort']['schema']
+export type InferSearchResultsSchema<TSchema extends AnyModelSchema> = TSchema['definition']['search']['schema']

package/src/shared/utils/schema-inheritance.ts

@@ -0,0 +1,28 @@
+import type { AnyModelSchema, Model, ModelSchema } from '@declaro/core'
+import type { InferEntityMetadata } from './schema-inference'
+
+/**
+ * Represents a child schema that inherits from a parent schema.
+ * This is useful for creating schemas that extend the functionality of an existing schema.
+ * It replaces the schema name and all model names with a string type.
+ *
+ * @warning This type is intended for use in generic types. In most cases, you should use concrete schemas for inheritance for best type inference.
+ *
+ * @template TSchema - The parent schema type.
+ * @example
+ * ```ts
+ * import { ModelSchema, ChildSchema } from '@declaro/core';
+ *
+ * export class ParentService<TSchema extends ChildSchema<typeof ParentSchema>> extends ModelService<TSchema> {
+ *     constructor(args: IModelServiceArgs<TSchema>) {
+ *         super(args);
+ *     }
+ * }
+ */
+export type ChildSchema<TSchema extends AnyModelSchema> = ModelSchema<
+    string,
+    {
+        [K in keyof TSchema['definition']]: Model<string, TSchema['definition'][K]['schema']>
+    },
+    InferEntityMetadata<TSchema>
+>