@declaro/data 2.0.0-beta.121 → 2.0.0-beta.125

package/src/domain/events/query-event.test.ts

@@ -1,28 +1,228 @@
 import { describe, it, expect } from 'bun:test'
 import { QueryEvent } from './query-event'
+import { ActionDescriptor, type IActionDescriptorInput } from '@declaro/core'
+
+interface IBookResult {
+    id: string
+    title: string
+    description: string
+    author: string
+    year: number
+}
+
+interface ILoadParams {
+    id: string
+}
+
+interface ISearchParams {
+    text?: string
+    author?: string
+    year?: number
+}
+
+interface ICustomMeta {
+    customField?: string
+    anotherField?: number
+}
 
 describe('QueryEvent', () => {
-    describe('load action', () => {
-        it('should lookup a book with the given lookup', () => {
-            const params = { id: 42 }
-            const descriptor = { namespace: 'books', action: 'load' }
-            const query = new QueryEvent(descriptor, params, {})
-
-            expect(query.descriptor.namespace).toBe('books')
-            expect(query.descriptor.action).toBe('load')
-            expect(query.meta.input).toEqual(params)
-        })
+    it('should create a query event with params and descriptor', () => {
+        const params: ILoadParams = { id: '1' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'load' }
+        const event = new QueryEvent<IBookResult, ILoadParams>(descriptor, params)
+
+        expect(event.input).toEqual(params)
+        expect(event.descriptor.toString()).toEqual(new ActionDescriptor(descriptor).toString())
+        expect(event.meta).toEqual({})
+        expect(event.data).toBeUndefined()
+    })
+
+    it('should set result correctly', () => {
+        const params: ILoadParams = { id: '1' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'load' }
+        const event = new QueryEvent<IBookResult, ILoadParams>(descriptor, params)
+
+        expect(event.data).toBeUndefined()
+
+        const result: IBookResult = {
+            id: '1',
+            title: 'Test Book',
+            description: 'A book for testing',
+            author: 'Author Name',
+            year: 2024,
+        }
+        event.setResult(result)
+
+        expect(event.data).toEqual(result)
+    })
+
+    it('should update meta correctly', () => {
+        const params: ISearchParams = { text: '1984' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'search' }
+        const event = new QueryEvent<IBookResult[], ISearchParams, ICustomMeta>(descriptor, params)
+
+        event.setMeta({ customField: 'custom value' })
+
+        expect(event.meta.customField).toBe('custom value')
+    })
+
+    it('should serialize to JSON with eventId and timestamp', () => {
+        const params: ILoadParams = { id: '1' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'load' }
+        const event = new QueryEvent<IBookResult, ILoadParams>(descriptor, params)
+
+        const result: IBookResult = {
+            id: '1',
+            title: 'Test Book',
+            description: 'A book for testing',
+            author: 'Author Name',
+            year: 2024,
+        }
+        event.setResult(result)
+
+        const json = event.toJSON()
+
+        expect(json.eventId).toBeDefined()
+        expect(json.timestamp).toBeDefined()
+        expect(json.type).toBe('books::book.load')
+        expect(json.input).toEqual(params)
+        expect(json.data).toEqual(result)
+    })
+
+    it('should handle chaining of setter methods', () => {
+        const params: ILoadParams = { id: '1' }
+        const result: IBookResult = {
+            id: '1',
+            title: 'Test Book',
+            description: 'A book for testing',
+            author: 'Author Name',
+            year: 2024,
+        }
+
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'load' }
+        const event = new QueryEvent<IBookResult, ILoadParams, ICustomMeta>(descriptor, params)
+            .setMeta({ customField: 'value' })
+            .setResult(result)
+
+        expect(event.input).toEqual(params)
+        expect(event.meta.customField).toBe('value')
+        expect(event.data).toEqual(result)
     })
 
-    describe('search action', () => {
-        it('should search for books with the given filters', () => {
-            const params = { text: '1984' }
-            const descriptor = { namespace: 'books', action: 'search' }
-            const query = new QueryEvent(descriptor, params, {})
+    it('should update input after initialization', () => {
+        const params: ISearchParams = { text: '1984' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'search' }
+        const event = new QueryEvent<IBookResult[], ISearchParams>(descriptor, params)
 
-            expect(query.descriptor.namespace).toBe('books')
-            expect(query.descriptor.action).toBe('search')
-            expect(query.meta.input).toEqual(params)
+        const newParams: ISearchParams = {
+            text: 'Brave New World',
+            author: 'Aldous Huxley',
+        }
+        event.setInput(newParams)
+
+        expect(event.input).toEqual(newParams)
+    })
+
+    it('should maintain type throughout lifecycle', () => {
+        const params: ILoadParams = { id: '1' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'load' }
+        const event = new QueryEvent<IBookResult, ILoadParams>(descriptor, params)
+
+        expect(event.type).toBe('books::book.load')
+
+        event.setInput({ id: '2' })
+        expect(event.type).toBe('books::book.load')
+
+        const result: IBookResult = {
+            id: '2',
+            title: 'Another Book',
+            description: 'Another description',
+            author: 'Another Author',
+            year: 2025,
+        }
+        event.setResult(result)
+        expect(event.type).toBe('books::book.load')
+    })
+
+    it('should handle search action with multiple filters', () => {
+        const params: ISearchParams = {
+            text: 'science fiction',
+            author: 'Isaac Asimov',
+            year: 1950,
+        }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'search' }
+        const event = new QueryEvent<IBookResult[], ISearchParams>(descriptor, params)
+
+        expect(event.descriptor.action).toBe('search')
+        expect(event.input).toEqual(params)
+    })
+
+    it('should handle search results as array', () => {
+        const params: ISearchParams = { text: 'Foundation' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'search' }
+        const event = new QueryEvent<IBookResult[], ISearchParams>(descriptor, params)
+
+        const results: IBookResult[] = [
+            {
+                id: '1',
+                title: 'Foundation',
+                description: 'First book',
+                author: 'Isaac Asimov',
+                year: 1951,
+            },
+            {
+                id: '2',
+                title: 'Foundation and Empire',
+                description: 'Second book',
+                author: 'Isaac Asimov',
+                year: 1952,
+            },
+        ]
+        event.setResult(results)
+
+        expect(event.data).toEqual(results)
+        expect(event.data?.length).toBe(2)
+    })
+
+    it('should handle load action with single result', () => {
+        const params: ILoadParams = { id: '42' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'load' }
+        const event = new QueryEvent<IBookResult, ILoadParams>(descriptor, params)
+
+        const result: IBookResult = {
+            id: '42',
+            title: "The Hitchhiker's Guide to the Galaxy",
+            description: "Don't Panic",
+            author: 'Douglas Adams',
+            year: 1979,
+        }
+        event.setResult(result)
+
+        expect(event.data).toEqual(result)
+        expect(event.descriptor.action).toBe('load')
+    })
+
+    it('should serialize meta to JSON', () => {
+        const params: ISearchParams = { text: 'test' }
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'search' }
+        const event = new QueryEvent<IBookResult[], ISearchParams, ICustomMeta>(descriptor, params, {
+            customField: 'custom value',
+            anotherField: 123,
         })
+
+        const json = event.toJSON()
+
+        expect(json.meta.customField).toBe('custom value')
+        expect(json.meta.anotherField).toBe(123)
+        expect(json.input).toEqual(params)
+    })
+
+    it('should handle empty search params', () => {
+        const params: ISearchParams = {}
+        const descriptor: IActionDescriptorInput = { namespace: 'books', resource: 'book', action: 'search' }
+        const event = new QueryEvent<IBookResult[], ISearchParams>(descriptor, params)
+
+        expect(event.input).toEqual({})
+        expect(event.descriptor.action).toBe('search')
     })
 })

package/src/domain/events/query-event.ts

@@ -1,7 +1,13 @@
 import type { IActionDescriptorInput } from '@declaro/core'
-import { RequestEvent } from './request-event'
+import { RequestEvent, type IRequestEventMeta } from './request-event'
 
-export class QueryEvent<TResult, TParams, TMeta = any> extends RequestEvent<TResult, TParams, TMeta> {
+export interface IQueryEventMeta<TResult> extends IRequestEventMeta {}
+
+export class QueryEvent<
+    TResult,
+    TParams,
+    TMeta extends IQueryEventMeta<TResult> = IQueryEventMeta<TResult>,
+> extends RequestEvent<TResult, TParams, TMeta> {
     constructor(descriptor: IActionDescriptorInput, params: TParams, meta: TMeta = {} as TMeta) {
         super(descriptor, params, meta)
     }

package/src/domain/events/request-event.test.ts

@@ -10,7 +10,7 @@ describe('RequestEvent', () => {
         })
 
         expect(event.meta.foo).toBe('bar')
-        expect(event.meta.input?.key).toBe('value')
+        expect(event.input?.key).toBe('value')
     })
 
     it('should update meta correctly', () => {

package/src/domain/events/request-event.ts

@@ -1,22 +1,30 @@
 import type { IActionDescriptorInput, Simplify } from '@declaro/core'
 import { DomainEvent } from './domain-event'
 
-export interface IRequestEventInput<TInput> {
+export interface IRequestEventMeta {}
+
+export interface IRequestEventJSON<TInput, TMeta = IRequestEventMeta> extends Simplify<DomainEvent<TInput, TMeta>> {
     input: TInput
 }
 
-export class RequestEvent<TResult, TInput, TMeta = any> extends DomainEvent<
+export class RequestEvent<TResult, TInput, TMeta extends IRequestEventMeta = IRequestEventMeta> extends DomainEvent<
     TResult,
-    Simplify<IRequestEventInput<TInput> & TMeta>
+    TMeta
 > {
+    input: TInput
+
     constructor(descriptor: IActionDescriptorInput, input: TInput, meta: TMeta = {} as TMeta) {
         super({
-            meta: {
-                ...meta,
-                input,
-            },
+            meta,
             descriptor,
         })
+
+        this.input = input
+    }
+
+    setInput(input: TInput): this {
+        this.input = input
+        return this
     }
 
     setMeta(meta: Partial<TMeta>): this {
@@ -29,4 +37,11 @@ export class RequestEvent<TResult, TInput, TMeta = any> extends DomainEvent<
 
         return this
     }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            input: this.input,
+        }
+    }
 }

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

@@ -138,13 +138,13 @@ describe('ModelService - Normalization', () => {
             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(beforeCreateCall.input.title).toBe('Test Book')
+            expect(beforeCreateCall.input.author).toBe('Author Name')
+            expect(beforeCreateCall.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'))
+            expect(afterCreateCall.input.title).toBe('Test Book')
+            expect(afterCreateCall.input.author).toBe('Author Name')
+            expect(afterCreateCall.input.publishedDate).toEqual(new Date('2023-01-01'))
         })
 
         it('should call normalizeInput method exactly once per input during bulkUpsert with Promise.all', async () => {

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

@@ -1,11 +1,8 @@
-import { describe, it, expect, beforeEach } from 'bun:test'
-import { ModelService } from './model-service'
-import { MockMemoryRepository } from '../../test/mock/repositories/mock-memory-repository'
-import { MockBookSchema, type MockBookInput } from '../../test/mock/models/mock-book-models'
 import { EventManager } from '@declaro/core'
-import { mock } from 'bun:test'
-import type { InferDetail } from '../../shared/utils/schema-inference'
-import { ModelMutationAction } from '../events/event-types'
+import { beforeEach, describe, expect, it, mock } from 'bun:test'
+import { MockBookSchema } from '../../test/mock/models/mock-book-models'
+import { MockMemoryRepository } from '../../test/mock/repositories/mock-memory-repository'
+import { ModelService } from './model-service'
 
 describe('ModelService', () => {
     const namespace = 'books'