@declaro/data 2.0.0-beta.126 → 2.0.0-beta.128

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

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

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

@@ -0,0 +1,295 @@
+import { describe, expect, test } from 'bun:test'
+import type { ChildSchema } from './schema-inheritance'
+import type { IAnimalTraitSchema } from './test/animal-trait-schema'
+import type { IElephantSchema } from './test/elephant-schema'
+import type { IAnimalSchema } from './test/animal-schema'
+import type { IElephantTraitSchema } from './test/elephant-trait-schema'
+import type { InferDetail } from './schema-inference'
+
+// Service Classes using ChildSchema
+
+class AnimalService<TSchema extends ChildSchema<IAnimalSchema>> {
+    getTraits(animal?: InferDetail<TSchema>): InferDetail<IAnimalTraitSchema>[] {
+        return animal?.traits ?? []
+    }
+}
+
+class ElephantService extends AnimalService<IElephantSchema> {
+    getTrunkLength(elephant?: InferDetail<IElephantSchema>): number {
+        return elephant?.trunkLength ?? 0
+    }
+}
+
+class AnimalTraitService<TSchema extends ChildSchema<IAnimalTraitSchema>> {
+    isTitleLong(trait?: InferDetail<TSchema>): boolean {
+        return (trait?.title.length ?? 0) > 10
+    }
+}
+
+class ElephantTraitService extends AnimalTraitService<IElephantTraitSchema> {
+    isSharpTrait(trait?: InferDetail<IElephantTraitSchema>): boolean {
+        return trait?.isSharp ?? false
+    }
+}
+
+describe('Schema Inheritance Utils', () => {
+    describe('AnimalService', () => {
+        test('should get traits from animal detail', () => {
+            const service = new AnimalService()
+            const animal = {
+                name: 'Lion',
+                sound: 'Roar',
+                traits: [
+                    { title: 'Carnivore', description: 'Eats meat', animal: undefined },
+                    { title: 'Predator', description: 'Hunts prey', animal: undefined },
+                ],
+            }
+
+            const traits = service.getTraits(animal)
+
+            expect(traits).toHaveLength(2)
+            expect(traits[0].title).toBe('Carnivore')
+            expect(traits[1].title).toBe('Predator')
+        })
+
+        test('should return empty array when animal has no traits', () => {
+            const service = new AnimalService()
+            const animal = {
+                name: 'Lion',
+                sound: 'Roar',
+                traits: [],
+            }
+
+            const traits = service.getTraits(animal)
+
+            expect(traits).toEqual([])
+        })
+
+        test('should return empty array when animal is undefined', () => {
+            const service = new AnimalService()
+
+            const traits = service.getTraits(undefined)
+
+            expect(traits).toEqual([])
+        })
+    })
+
+    describe('ElephantService', () => {
+        test('should inherit getTraits from AnimalService', () => {
+            const service = new ElephantService()
+            const elephant = {
+                name: 'Dumbo',
+                sound: 'Trumpet',
+                trunkLength: 150,
+                traits: [
+                    {
+                        title: 'Long trunk',
+                        description: 'Very long trunk',
+                        isSharp: false,
+                        length: 150,
+                        animal: undefined,
+                    },
+                ],
+            }
+
+            const traits = service.getTraits(elephant)
+
+            expect(traits).toHaveLength(1)
+            expect(traits[0].title).toBe('Long trunk')
+        })
+
+        test('should get trunk length from elephant', () => {
+            const service = new ElephantService()
+            const elephant = {
+                name: 'Dumbo',
+                sound: 'Trumpet',
+                trunkLength: 150,
+                traits: [],
+            }
+
+            const trunkLength = service.getTrunkLength(elephant)
+
+            expect(trunkLength).toBe(150)
+        })
+
+        test('should return 0 when elephant is undefined', () => {
+            const service = new ElephantService()
+
+            const trunkLength = service.getTrunkLength(undefined)
+
+            expect(trunkLength).toBe(0)
+        })
+
+        test('should handle elephant with zero trunk length', () => {
+            const service = new ElephantService()
+            const elephant = {
+                name: 'Baby Elephant',
+                sound: 'Squeak',
+                trunkLength: 0,
+                traits: [],
+            }
+
+            const trunkLength = service.getTrunkLength(elephant)
+
+            expect(trunkLength).toBe(0)
+        })
+    })
+
+    describe('AnimalTraitService', () => {
+        test('should identify long titles', () => {
+            const service = new AnimalTraitService()
+            const trait = {
+                title: 'This is a very long title',
+                description: 'Description',
+                animal: undefined,
+            }
+
+            const isLong = service.isTitleLong(trait)
+
+            expect(isLong).toBe(true)
+        })
+
+        test('should identify short titles', () => {
+            const service = new AnimalTraitService()
+            const trait = {
+                title: 'Short',
+                description: 'Description',
+                animal: undefined,
+            }
+
+            const isLong = service.isTitleLong(trait)
+
+            expect(isLong).toBe(false)
+        })
+
+        test('should handle exactly 10 character titles as short', () => {
+            const service = new AnimalTraitService()
+            const trait = {
+                title: '1234567890',
+                description: 'Description',
+                animal: undefined,
+            }
+
+            const isLong = service.isTitleLong(trait)
+
+            expect(isLong).toBe(false)
+        })
+
+        test('should return false when trait is undefined', () => {
+            const service = new AnimalTraitService()
+
+            const isLong = service.isTitleLong(undefined)
+
+            expect(isLong).toBe(false)
+        })
+    })
+
+    describe('ElephantTraitService', () => {
+        test('should inherit isTitleLong from AnimalTraitService', () => {
+            const service = new ElephantTraitService()
+            const trait = {
+                title: 'Very long elephant trait title',
+                description: 'Description',
+                isSharp: true,
+                length: 50,
+                animal: undefined,
+            }
+
+            const isLong = service.isTitleLong(trait)
+
+            expect(isLong).toBe(true)
+        })
+
+        test('should identify sharp traits', () => {
+            const service = new ElephantTraitService()
+            const trait = {
+                title: 'Sharp tusk',
+                description: 'A sharp tusk',
+                isSharp: true,
+                length: 100,
+                animal: undefined,
+            }
+
+            const isSharp = service.isSharpTrait(trait)
+
+            expect(isSharp).toBe(true)
+        })
+
+        test('should identify non-sharp traits', () => {
+            const service = new ElephantTraitService()
+            const trait = {
+                title: 'Soft ear',
+                description: 'A soft ear',
+                isSharp: false,
+                length: 50,
+                animal: undefined,
+            }
+
+            const isSharp = service.isSharpTrait(trait)
+
+            expect(isSharp).toBe(false)
+        })
+
+        test('should return false when trait is undefined', () => {
+            const service = new ElephantTraitService()
+
+            const isSharp = service.isSharpTrait(undefined)
+
+            expect(isSharp).toBe(false)
+        })
+
+        test('should handle both inherited and own methods', () => {
+            const service = new ElephantTraitService()
+            const trait = {
+                title: 'Long and sharp tusk trait',
+                description: 'Description',
+                isSharp: true,
+                length: 150,
+                animal: undefined,
+            }
+
+            const isLong = service.isTitleLong(trait)
+            const isSharp = service.isSharpTrait(trait)
+
+            expect(isLong).toBe(true)
+            expect(isSharp).toBe(true)
+        })
+    })
+
+    describe('Schema Inheritance Type Safety', () => {
+        test('should allow ElephantService to work with elephant-specific properties', () => {
+            const service = new ElephantService()
+            const elephant = {
+                name: 'Babar',
+                sound: 'Trumpet',
+                trunkLength: 200,
+                traits: [],
+            }
+
+            // Should compile and work with both animal and elephant properties
+            const traits = service.getTraits(elephant)
+            const trunkLength = service.getTrunkLength(elephant)
+
+            expect(traits).toEqual([])
+            expect(trunkLength).toBe(200)
+        })
+
+        test('should allow ElephantTraitService to work with elephant trait properties', () => {
+            const service = new ElephantTraitService()
+            const trait = {
+                title: 'Trait',
+                description: 'Desc',
+                isSharp: true,
+                length: 75,
+                animal: undefined,
+            }
+
+            // Should compile and work with both animal trait and elephant trait properties
+            const isLong = service.isTitleLong(trait)
+            const isSharp = service.isSharpTrait(trait)
+
+            expect(isLong).toBe(false)
+            expect(isSharp).toBe(true)
+        })
+    })
+})

package/src/shared/utils/test/animal-schema.ts

@@ -0,0 +1,46 @@
+// Animal Schema
+
+import { ModelSchema } from '@declaro/core'
+import { sortArray, ZodModel } from '@declaro/zod'
+import z4 from 'zod/v4'
+import { AnimalTraitsDetailSchema, AnimalTraitsSummarySchema } from './animal-trait-schema'
+
+export const AnimalDetailSchema = z4.object({
+    name: z4.string(),
+    sound: z4.string(),
+    get traits() {
+        return z4.array(AnimalTraitsDetailSchema)
+    },
+})
+
+export const AnimalLookupSchema = z4.object({
+    id: z4.number(),
+})
+
+export const AnimalFiltersSchema = z4.object({
+    text: z4.string().optional(),
+    sound: z4.string().optional(),
+})
+
+export const AnimalSortSchema = sortArray(['name', 'sound'])
+
+export const AnimalSummarySchema = z4.object({
+    name: z4.string(),
+    sound: z4.string(),
+    get traits() {
+        return z4.array(AnimalTraitsSummarySchema)
+    },
+})
+
+export const AnimalSchema = ModelSchema.create('AnimalSchema')
+    .read({
+        detail: (h) => new ZodModel('AnimalDetail', AnimalDetailSchema),
+        lookup: (h) => new ZodModel('AnimalLookup', AnimalLookupSchema),
+    })
+    .search({
+        filters: (h) => new ZodModel('AnimalFilters', AnimalFiltersSchema),
+        sort: (h) => new ZodModel('AnimalSort', AnimalSortSchema),
+        summary: (h) => new ZodModel('AnimalSummary', AnimalSummarySchema),
+    })
+
+export type IAnimalSchema = typeof AnimalSchema

package/src/shared/utils/test/animal-trait-schema.ts

@@ -0,0 +1,45 @@
+import { sortArray, ZodModel } from '@declaro/zod'
+import { AnimalDetailSchema, AnimalSummarySchema } from './animal-schema'
+
+// Animal Traits Schema
+
+import { ModelSchema } from '@declaro/core'
+import z4 from 'zod/v4'
+
+export const AnimalTraitsDetailSchema = z4.object({
+    title: z4.string(),
+    description: z4.string(),
+    get animal() {
+        return AnimalDetailSchema.optional()
+    },
+})
+
+export const AnimalTraitsSummarySchema = z4.object({
+    title: z4.string(),
+    get animal() {
+        return AnimalSummarySchema.optional()
+    },
+})
+
+export const AnimalTraitsLookupSchema = z4.object({
+    id: z4.number(),
+})
+
+export const AnimalTraitsFiltersSchema = z4.object({
+    text: z4.string().optional(),
+})
+
+export const AnimalTraitsSortSchema = sortArray(['title'])
+
+export const AnimalTraitsSchema = ModelSchema.create('AnimalTraitsSchema')
+    .read({
+        detail: (h) => new ZodModel('AnimalTraitsDetail', AnimalTraitsDetailSchema),
+        lookup: (h) => new ZodModel('AnimalTraitsLookup', AnimalTraitsLookupSchema),
+    })
+    .search({
+        filters: (h) => new ZodModel('AnimalTraitsFilters', AnimalTraitsFiltersSchema),
+        sort: (h) => new ZodModel('AnimalTraitsSort', AnimalTraitsSortSchema),
+        summary: (h) => new ZodModel('AnimalTraitsSummary', AnimalTraitsSummarySchema),
+    })
+
+export type IAnimalTraitSchema = typeof AnimalTraitsSchema

package/src/shared/utils/test/elephant-schema.ts

@@ -0,0 +1,58 @@
+// Elephant Schema inheriting from Animal Schema
+
+import z4 from 'zod/v4'
+import {
+    AnimalDetailSchema,
+    AnimalFiltersSchema,
+    AnimalLookupSchema,
+    AnimalSortSchema,
+    AnimalSummarySchema,
+} from './animal-schema'
+import { ModelSchema } from '@declaro/core'
+import { ZodModel } from '@declaro/zod'
+import { ElephantTraitsDetailSchema, ElephantTraitsSummarySchema } from './elephant-trait-schema'
+
+export const ElephantDetailSchema = z4.object({
+    ...AnimalDetailSchema.shape,
+    trunkLength: z4.number(),
+    get traits() {
+        return z4.array(ElephantTraitsDetailSchema)
+    },
+    get elephantDetails() {
+        return z4.object({
+            favoriteFood: z4.string(),
+            weight: z4.number(),
+        })
+    },
+})
+
+export const ElephantSummarySchema = z4.object({
+    ...AnimalSummarySchema.shape,
+    trunkLength: z4.number(),
+    get traits() {
+        return z4.array(ElephantTraitsSummarySchema)
+    },
+})
+
+export const ElephantLookupSchema = z4.object({
+    ...AnimalLookupSchema.shape,
+})
+
+export const ElephantFiltersSchema = z4.object({
+    ...AnimalFiltersSchema.shape,
+    minTrunkLength: z4.number().optional(),
+    maxTrunkLength: z4.number().optional(),
+})
+
+export const ElephantSchema = ModelSchema.create('ElephantSchema')
+    .read({
+        detail: (h) => new ZodModel('ElephantDetail', ElephantDetailSchema),
+        lookup: (h) => new ZodModel('ElephantLookup', ElephantLookupSchema),
+    })
+    .search({
+        filters: (h) => new ZodModel('ElephantFilters', ElephantFiltersSchema),
+        sort: (h) => new ZodModel('ElephantSort', AnimalSortSchema),
+        summary: (h) => new ZodModel('ElephantSummary', ElephantSummarySchema),
+    })
+
+export type IElephantSchema = typeof ElephantSchema

package/src/shared/utils/test/elephant-trait-schema.ts

@@ -0,0 +1,53 @@
+// Elephant Traits Schema inheriting from Animal Traits Schema
+
+import z4 from 'zod/v4'
+import { ModelSchema } from '@declaro/core'
+import { ZodModel } from '@declaro/zod'
+import {
+    AnimalTraitsDetailSchema,
+    AnimalTraitsFiltersSchema,
+    AnimalTraitsLookupSchema,
+    AnimalTraitsSortSchema,
+    AnimalTraitsSummarySchema,
+} from './animal-trait-schema'
+import { ElephantDetailSchema, ElephantSummarySchema } from './elephant-schema'
+
+export const ElephantTraitsDetailSchema = z4.object({
+    ...AnimalTraitsDetailSchema.shape,
+    isSharp: z4.boolean(),
+    length: z4.number(),
+    get animal() {
+        return ElephantDetailSchema.optional()
+    },
+})
+
+export const ElephantTraitsSummarySchema = z4.object({
+    ...AnimalTraitsSummarySchema.shape,
+    isSharp: z4.boolean(),
+    length: z4.number(),
+    get animal() {
+        return ElephantSummarySchema.optional()
+    },
+})
+
+export const ElephantTraitsLookupSchema = z4.object({
+    ...AnimalTraitsLookupSchema.shape,
+})
+
+export const ElephantTraitsFiltersSchema = z4.object({
+    ...AnimalTraitsFiltersSchema.shape,
+    isSharp: z4.boolean().optional(),
+})
+
+export const ElephantTraitsSchema = ModelSchema.create('ElephantTraitsSchema')
+    .read({
+        detail: (h) => new ZodModel('ElephantTraitsDetail', ElephantTraitsDetailSchema),
+        lookup: (h) => new ZodModel('ElephantTraitsLookup', ElephantTraitsLookupSchema),
+    })
+    .search({
+        filters: (h) => new ZodModel('ElephantTraitsFilters', ElephantTraitsFiltersSchema),
+        sort: (h) => new ZodModel('ElephantTraitsSort', AnimalTraitsSortSchema),
+        summary: (h) => new ZodModel('ElephantTraitsSummary', ElephantTraitsSummarySchema),
+    })
+
+export type IElephantTraitSchema = typeof ElephantTraitsSchema

package/dist/ts/test/mock/repositories/mock-memory-repository.custom-lookup.test.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=mock-memory-repository.custom-lookup.test.d.ts.map

package/dist/ts/test/mock/repositories/mock-memory-repository.custom-lookup.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mock-memory-repository.custom-lookup.test.d.ts","sourceRoot":"","sources":["../../../../../src/test/mock/repositories/mock-memory-repository.custom-lookup.test.ts"],"names":[],"mappings":""}