@declaro/core 2.0.0-y.0 → 2.1.0

package/src/context/legacy-context.test.ts

@@ -1,10 +1,10 @@
 import { Context } from './context'
 import { sleep } from '../timing'
 import { ContextConsumer } from './context-consumer'
-import { describe, it, vi } from 'vitest'
+import { describe, it, vi, expect } from 'vitest'
 
 describe('Context', () => {
-    it('Should allow simple value dependency injection', async ({ expect }) => {
+    it('Should allow simple value dependency injection', async () => {
         const context = new Context()
 
         context.provide('test', 'Hello World')
@@ -20,7 +20,7 @@ describe('Context', () => {
         expect(number).toBe(42)
     })
 
-    it('Should allow subscription to arbitrary events', async ({ expect }) => {
+    it('Should allow subscription to arbitrary events', async () => {
         const customEventCall = vi.fn()
 
         const context = new Context()
@@ -38,7 +38,7 @@ describe('Context', () => {
         expect(customEventCall.mock.calls.length).toBe(1)
     })
 
-    it('Should extend other contexts', async ({ expect }) => {
+    it('Should extend other contexts', async () => {
         const context1 = new Context()
         const context2 = new Context()
         const context3 = new Context()
@@ -65,7 +65,7 @@ describe('Context', () => {
         expect(symbolValue).toBe(42)
     })
 
-    it('Should nest contexts', async ({ expect }) => {
+    it('Should nest contexts', async () => {
         const context1 = new Context()
         const context2 = new Context()
 
@@ -81,7 +81,7 @@ describe('Context', () => {
         expect(a2).toBe(2)
     })
 
-    it('Should allow async middleware', async ({ expect }) => {
+    it('Should allow async middleware', async () => {
         const context = new Context()
 
         await context.use(async (context) => {
@@ -96,7 +96,7 @@ describe('Context', () => {
         expect(test2).toBe('Hello Test')
     })
 
-    it('Should allow singletons', ({ expect }) => {
+    it('Should allow singletons', () => {
         const context = new Context()
 
         const KEY = Symbol()
@@ -107,7 +107,7 @@ describe('Context', () => {
         expect(instance).toBe(1)
     })
 
-    it('Should allow hydration', ({ expect }) => {
+    it('Should allow hydration', () => {
         const context = new Context()
 
         class Test extends ContextConsumer {
@@ -123,7 +123,7 @@ describe('Context', () => {
         expect(context.hydrate(Test).test()).toBe('Yes')
     })
 
-    it('Should allow hydration with args', ({ expect }) => {
+    it('Should allow hydration with args', () => {
         const context = new Context()
 
         class Test extends ContextConsumer {

package/src/dataflow/objects.test.ts

@@ -2,7 +2,7 @@ import { merge } from './objects'
 import { describe, expect, it } from 'vitest'
 
 describe('Object manipulation tests', () => {
-    it('Should merge objects', ({ expect }) => {
+    it('Should merge objects', () => {
         const CUSTOM_KEY = Symbol()
 
         const objectA = {
@@ -56,7 +56,7 @@ describe('Object manipulation tests', () => {
         expect(output.characters[3]).toBe('Chewie')
     })
 
-    it('Should add non-array items to matching arrays', ({ expect }) => {
+    it('Should add non-array items to matching arrays', () => {
         const a = {
             val: 4,
             arr: [1, 2],
@@ -78,7 +78,7 @@ describe('Object manipulation tests', () => {
         expect(c.arr[2]).toBe(3)
     })
 
-    it('Should handle nulls gracefully', ({ expect }) => {
+    it('Should handle nulls gracefully', () => {
         const a = {
             val: null,
             obj: undefined,
@@ -94,11 +94,11 @@ describe('Object manipulation tests', () => {
 
         const c = merge(a, b)
 
-        expect(c.val[0]).toBe(5)
-        expect(c.val[1]).toBe(6)
+        expect(c.val?.[0]).toBe(5)
+        expect(c.val?.[1]).toBe(6)
 
-        expect(c.obj.a).toBe(1)
-        expect(c.obj.b).toBe(2)
+        expect(c.obj?.a).toBe(1)
+        expect(c.obj?.b).toBe(2)
     })
 
     // it('Should handle circular structures', () => {

package/src/dataflow/objects.ts

@@ -1,22 +1,26 @@
-export function merge<T, Source1>(target: T, source1: Source1): T & Source1
+// K extends keyof B ? B[K] : K extends keyof A ? A[K] : never
+
+import type { Merge } from '../typescript'
+
+export function merge<T, Source1>(target: T, source1: Source1): Merge<T, Source1>
 export function merge<T, Source1, Source2>(
     target: T,
     source1: Source1,
     source2: Source2,
-): T & Source1 & Source2
+): Merge<Merge<T, Source1>, Source2>
 export function merge<T, Source1, Source2, Source3>(
     target: T,
     source1: Source1,
     source2: Source2,
     source3: Source3,
-): T & Source1 & Source2 & Source3
+): Merge<Merge<Merge<T, Source1>, Source2>, Source3>
 export function merge<T, Source1, Source2, Source3, Source4>(
     target: T,
     source1: Source1,
     source2: Source2,
     source3: Source3,
     source4: Source4,
-): T & Source1 & Source2 & Source3 & Source4
+): Merge<Merge<Merge<Merge<T, Source1>, Source2>, Source3>, Source4>
 export function merge<T, Source1, Source2, Source3, Source4, Source5>(
     target: T,
     source1: Source1,
@@ -24,7 +28,7 @@ export function merge<T, Source1, Source2, Source3, Source4, Source5>(
     source3: Source3,
     source4: Source4,
     source5: Source5,
-): T & Source1 & Source2 & Source3 & Source4 & Source5
+): Merge<Merge<Merge<Merge<Merge<T, Source1>, Source2>, Source3>, Source4>, Source5>
 export function merge(target: any, ...sources: any[]): any[] {
     const recursions = []
     return sources.reduce((workingCopy, source) => {
@@ -38,10 +42,7 @@ export function merge(target: any, ...sources: any[]): any[] {
                 value = [existingValue, ...value].filter((item) => !!item)
             } else if (Array.isArray(existingValue) && !Array.isArray(value)) {
                 value = [...(existingValue ?? []), value]
-            } else if (
-                typeof value === 'object' &&
-                typeof existingValue === 'object'
-            ) {
+            } else if (typeof value === 'object' && typeof existingValue === 'object') {
                 value = {
                     ...existingValue,
                     ...value,

package/src/errors/errors.ts

@@ -1,11 +1,13 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+
 export interface IError {
     code: number
     message: string
-    meta: any
+    meta?: any
 }
 
 export abstract class BaseError extends Error implements IError {
-    public readonly meta: any
+    public readonly meta?: any // Made optional
     public readonly code: number = 500
 
     constructor(message: string, meta?: any) {
@@ -36,12 +38,26 @@ export class SystemError extends BaseError {
     }
 }
 
+export interface ValidationErrorMeta {
+    result: StandardSchemaV1.Result<any>
+    [key: string]: any
+}
+
 export class ValidationError extends BaseError {
     public readonly code: number = 400
+    public readonly meta?: ValidationErrorMeta
 
-    constructor(message: string, meta?: any) {
+    constructor(message: string, meta?: ValidationErrorMeta) {
         super(message, meta)
         this.name = 'ValidationError'
+        this.meta = meta
+    }
+
+    public toJSON() {
+        return {
+            ...super.toJSON(),
+            result: this.meta?.result,
+        }
     }
 }
 

package/src/events/event-manager.spec.ts

@@ -14,6 +14,10 @@ describe('Event manager', () => {
             expect(event).toBe(testEvent)
         })
 
+        eventManager.on<TestEvent>('testx', (event) => {
+            const t = event.type
+        })
+
         eventManager.on('test', mockListener)
 
         await eventManager.emitAll(testEvent)
@@ -95,4 +99,129 @@ describe('Event manager', () => {
         expect(listener1.mock.calls.length).toBe(2)
         expect(listener2.mock.calls.length).toBe(2)
     })
+
+    it('should be able to forward events to another event manager', async () => {
+        const cb1 = vi.fn()
+        const cb2 = vi.fn()
+
+        const eventManager1 = new EventManager()
+        eventManager1.on('test', cb1)
+
+        const eventManager2 = new EventManager()
+        eventManager2.on('test', cb2)
+
+        eventManager2.forwardTo(eventManager1)
+
+        const testEvent = new TestEvent('test')
+        await eventManager2.emitAll(testEvent)
+
+        expect(cb1.mock.calls.length).toBe(1)
+        expect(cb2.mock.calls.length).toBe(1)
+        expect(cb1.mock.calls[0][0]).toBe(testEvent)
+        expect(cb2.mock.calls[0][0]).toBe(testEvent)
+        expect(eventManager1.getListeners('test').length).toBe(1)
+        expect(eventManager2.getListeners('test').length).toBe(2)
+    })
+
+    it('should await forwarded listeners', async () => {
+        const cb1 = vi.fn(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 10))
+        })
+        const cb2 = vi.fn(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 10))
+        })
+
+        const eventManager1 = new EventManager()
+        eventManager1.on('test', cb1)
+
+        const eventManager2 = new EventManager()
+        eventManager2.on('test', cb2)
+
+        eventManager2.forwardTo(eventManager1)
+
+        const testEvent = new TestEvent('test')
+        await eventManager2.emitAll(testEvent)
+
+        expect(cb1.mock.calls.length).toBe(1)
+        expect(cb2.mock.calls.length).toBe(1)
+
+        // Ensure all callbacks have finished by checking the resolved state of the promises
+        await expect(cb1.mock.results[0].value).resolves.toBeUndefined()
+        await expect(cb2.mock.results[0].value).resolves.toBeUndefined()
+
+        await eventManager2.emitAsync(testEvent)
+
+        expect(cb1.mock.calls.length).toBe(2)
+        expect(cb2.mock.calls.length).toBe(2)
+
+        // Ensure all callbacks have finished by checking the resolved state of the promises
+        await expect(cb1.mock.results[1].value).resolves.toBeUndefined()
+        await expect(cb2.mock.results[1].value).resolves.toBeUndefined()
+    })
+
+    it('should extend another event manager', async () => {
+        const eventManager1 = new EventManager()
+        const eventManager2 = new EventManager()
+
+        const cb1 = vi.fn()
+        const cb2 = vi.fn()
+
+        eventManager1.on('test', cb1)
+        eventManager2.on('test', cb2)
+
+        eventManager2.extend(eventManager1)
+
+        const testEvent = new TestEvent('test')
+
+        await eventManager2.emitAll(testEvent)
+        expect(cb1.mock.calls.length).toBe(1)
+        expect(cb2.mock.calls.length).toBe(1)
+        expect(cb1.mock.calls[0][0]).toBe(testEvent)
+        expect(cb2.mock.calls[0][0]).toBe(testEvent)
+    })
+
+    it('should correctly type the event listeners', async () => {
+        const eventManager = new EventManager()
+
+        interface CustomEvent extends IEvent {
+            type: 'custom'
+            data: string
+        }
+
+        const customListener = vi.fn((event: CustomEvent) => {
+            expect(event.type).toBe('custom')
+            expect(event.data).toBe('test data')
+        })
+
+        eventManager.on<CustomEvent>('custom', customListener)
+
+        const testEvent: CustomEvent = { type: 'custom', data: 'test data' }
+        await eventManager.emitAll(testEvent)
+
+        expect(customListener.mock.calls.length).toBe(1)
+    })
+
+    it('should bubble up errors from listeners', async () => {
+        const eventManager = new EventManager()
+        const testEvent = new TestEvent('test')
+        const errorMessage = 'Test error from listener'
+
+        // Test that emitAll bubbles up errors
+        const throwingListener = vi.fn(() => {
+            throw new Error(errorMessage)
+        })
+
+        eventManager.on('test', throwingListener)
+
+        await expect(eventManager.emitAll(testEvent)).rejects.toThrow(errorMessage)
+        expect(throwingListener.mock.calls.length).toBe(1)
+
+        // Test synchronous emit throws immediately
+        expect(() => eventManager.emit(testEvent)).toThrow(errorMessage)
+        expect(throwingListener.mock.calls.length).toBe(2)
+
+        // Test that emitAsync also bubbles up errors
+        await expect(eventManager.emitAsync(testEvent)).rejects.toThrow(errorMessage)
+        expect(throwingListener.mock.calls.length).toBe(3)
+    })
 })

package/src/events/event-manager.ts

@@ -1,12 +1,12 @@
 export interface IEvent {
-    type: string
+    type: Readonly<string>
 }
 
-export type Listener = (event: IEvent) => any
+export type Listener<E extends IEvent> = (event: E) => any
 
 export class EventManager<E extends IEvent = IEvent> {
     protected readonly listeners: {
-        [key: string]: Listener[]
+        [key: string]: Listener<E>[]
     } = {}
 
     getListeners(event: string) {
@@ -20,16 +20,31 @@ export class EventManager<E extends IEvent = IEvent> {
         return Object.keys(this.listeners)
     }
 
-    on(event: string | string[], listener: Listener) {
+    extend(eventManager: EventManager) {
+        const events = eventManager.getEvents()
+        events.forEach((event) => {
+            this.getListenerArray(event).push(...eventManager.getListeners(event))
+        })
+    }
+
+    forwardTo(eventManager: EventManager) {
+        const cancel = this.on('*', async (event) => {
+            await eventManager.emitAsync(event)
+        })
+
+        return cancel
+    }
+
+    on<Event extends E>(event: Event['type'] | Event['type'][], listener: Listener<Event>) {
         const events = Array.isArray(event) ? event : [event]
 
         events.forEach((e) => {
-            this.getListenerArray(e).push(listener)
+            this.getListenerArray(e).push(listener as Listener<E>)
         })
 
         return () => {
             events.forEach((e) => {
-                const index = this.getListeners(e).indexOf(listener)
+                const index = this.getListeners(e).indexOf(listener as Listener<E>)
                 if (index > -1) {
                     this.getListenerArray(e).splice(index, 1)
                 }
@@ -38,14 +53,10 @@ export class EventManager<E extends IEvent = IEvent> {
     }
 
     async emitAsync(event: E) {
-        await this.getListeners(event.type)
-            .reduce(async (promise, listener) => {
-                await promise
-                return await listener(event)
-            }, Promise.resolve())
-            .catch((e) => {
-                console.error('Error in event listener', e)
-            })
+        await this.getListeners(event.type).reduce(async (promise, listener) => {
+            await promise
+            return await listener(event)
+        }, Promise.resolve())
     }
 
     async emitAll(event: E) {

package/src/http/headers.ts

@@ -1,14 +1,29 @@
 import { Context } from '../context/context'
 import { useRequest } from './request'
 
-export type HeaderMap = Record<string, string>
-
+/**
+ * Get the headers from the request.
+ *
+ * @deprecated You can now inject headers directly from Context<RequestScope>.
+ * This function will be removed in a future version.
+ * @param context The context to use for the request.
+ * @returns The headers of the request, or an empty object if not available.
+ */
 export function useHeaders(context: Context) {
     const request = useRequest(context)
 
     return request?.headers ?? {}
 }
 
+/**
+ * Get a specific header from the request.
+ *
+ * @deprecated You can now inject headers directly from Context<RequestScope>.
+ * This function will be removed in a future version.
+ * @param context The context to use for the request.
+ * @param header The name of the header to retrieve.
+ * @returns The value of the specified header, or undefined if not available.
+ */
 export function useHeader(context: Context, header: string) {
     const headers = useHeaders(context)
 

package/src/http/request-context.ts

@@ -1,43 +1,52 @@
-import { Context, type ContextMiddleware } from '../context/context'
 import type { IncomingMessage, ServerResponse } from 'http'
-
-export const REQUEST_CONTEXT_MIDDLEWARE = Symbol('declaro:request-context-middleware')
-
-export function useRequestMiddleware(context: Context) {
-    const middleware = context.inject<ContextMiddleware[]>(REQUEST_CONTEXT_MIDDLEWARE)
+import { Context, type ContextMiddleware, type DeclaroScope } from '../context/context'
+
+/**
+ * Get the request middleware for the current context.
+ * @param context The context to retrieve middleware from.
+ * @returns An array of request middleware functions.
+ * @deprecated Use `context.scope.requestMiddleware` instead.
+ */
+export function useRequestMiddleware<S extends DeclaroScope>(context: Context<S>) {
+    const middleware = context.resolve('requestMiddleware', {
+        strict: false,
+    })
 
     return middleware ?? []
 }
 
-export function provideRequestMiddleware(context: Context, ...middleware: ContextMiddleware[]) {
-    const existingMiddleware = useRequestMiddleware(context)
+export function provideRequestMiddleware<S extends DeclaroScope>(
+    context: Context<S>,
+    ...middleware: ContextMiddleware<Context>[]
+) {
+    const existingMiddleware = context.scope.requestMiddleware ?? []
 
     const extendedMiddleware = [...existingMiddleware, ...middleware]
 
-    context.provide(REQUEST_CONTEXT_MIDDLEWARE, extendedMiddleware)
+    context.registerValue('requestMiddleware', extendedMiddleware as any)
 
     return extendedMiddleware
 }
 
-export const REQUEST_NODE_MIDDLEWARE = Symbol('declaro:request-node-middleware')
-
 export type NodeListener = (req: IncomingMessage, res: ServerResponse) => void
 export type NodePromisifiedHandler = (req: IncomingMessage, res: ServerResponse) => Promise<any>
 export type NodeMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any
 export type AllNodeMiddleware = NodeListener | NodePromisifiedHandler | NodeMiddleware
 
-export function useNodeMiddleware(context: Context) {
-    const middleware = context.inject<AllNodeMiddleware[]>(REQUEST_NODE_MIDDLEWARE)
+export function useNodeMiddleware<S extends DeclaroScope>(context: Context<S>) {
+    const middleware = context.resolve('nodeMiddleware', {
+        strict: false,
+    })
 
     return middleware ?? []
 }
 
-export function provideNodeMiddleware(context: Context, ...middleware: AllNodeMiddleware[]) {
+export function provideNodeMiddleware<S extends DeclaroScope>(context: Context<S>, ...middleware: AllNodeMiddleware[]) {
     const existingMiddleware = useNodeMiddleware(context)
 
     const extendedMiddleware = [...existingMiddleware, ...middleware]
 
-    context.provide(REQUEST_NODE_MIDDLEWARE, extendedMiddleware)
+    context.registerValue('nodeMiddleware', extendedMiddleware)
 
     return extendedMiddleware
 }

package/src/http/request.ts

@@ -1,20 +1,41 @@
-import { Context } from '../context/context'
 import type { IncomingMessage } from 'http'
-
-export const REQUEST = Symbol('declaro:request')
+import { Context, type DeclaroRequestScope } from '../context/context'
 
 export interface Request extends IncomingMessage {}
 
-export function provideRequest(context: Context, request: Request) {
-    context.provide(REQUEST, request)
+/**
+ * Provide a request to a context that supports request scope.
+ * The context must have all properties required by DeclaroRequestScope.
+ *
+ * @param context A context that includes DeclaroRequestScope properties
+ * @param request The request to provide
+ */
+export function provideRequest<S extends DeclaroRequestScope>(context: Context<S>, request: Request) {
+    context.registerValue('request', request)
 }
 
+/**
+ * Get the request from the context.
+ *
+ * @deprecated You can now inject the request directly from Context<RequestScope>.
+ * This function will be removed in a future version.
+ * @param context The context to use for the request.
+ * @returns
+ */
 export function useRequest(context: Context) {
-    const request = context.inject<Request | undefined>(REQUEST)
+    const request = context.resolve('request')
 
     return request
 }
 
+/**
+ * Get the HTTP method of the request.
+ *
+ * @deprecated You can now inject the request directly from Context<RequestScope>.
+ * This function will be removed in a future version.
+ * @param context The context to use for the request.
+ * @returns The HTTP method of the request, or undefined if not available.
+ */
 export function useRequestMethod(context: Context) {
     const request = useRequest(context)
 

package/src/http/url.ts

@@ -2,11 +2,11 @@ import { Context } from '../context/context'
 import { URL } from 'whatwg-url'
 import { useRequest } from './request'
 
-export function useRequestURL(context: Context) {
+export function useRequestURL(context: Context): URL | undefined {
     const request = useRequest(context)
     const url = request?.url && new URL(request?.url)
 
-    return url
+    return url as URL
 }
 
 export function useRequestURLString(context: Context) {
@@ -33,7 +33,7 @@ export function useRequestQuery(context: Context): Record<string, string> {
     const qs = url?.searchParams
 
     // convert qs to an object of key value pairs
-    const qsMap = [...qs?.entries()].reduce((qsMap, [key, value]) => {
+    const qsMap = [...(qs?.entries() as any)].reduce((qsMap, [key, value]) => {
         qsMap[key] = value
         return qsMap
     }, {} as Record<string, string>)

package/src/index.ts

@@ -1,19 +1,50 @@
+export type {
+    /**
+     * @deprecated Import AppScope from '#scope' instead.
+     *
+     * Migration: Change `import { AppScope } from '@declaro/core'` to `import { AppScope } from '#scope'`
+     *
+     * The #scope import allows for better type augmentation and module resolution.
+     */
+    AppScope,
+    /**
+     * @deprecated Import RequestScope from '#scope' instead.
+     *
+     * Migration: Change `import { RequestScope } from '@declaro/core'` to `import { RequestScope } from '#scope'`
+     *
+     * The #scope import allows for better type augmentation and module resolution.
+     */
+    RequestScope,
+} from '#scope'
+
+export * from '@standard-schema/spec'
+
 export * from './typescript'
 export * from './app'
+export * from './application/create-request-context'
+export * from './application/use-declaro'
 export * from './context/context'
 export * from './context/context-consumer'
 export * from './context/validators'
+export * from './context/async-context'
 export * from './dataflow'
 export * from './events'
 export * from './validation'
 export * from './timing'
-export * from './schema'
-export * from './helpers'
+export * from './scope'
 export * from './errors/errors'
-export * from './schema/formats'
 export * from './pipelines'
 export * from './http/headers'
 export * from './http/request-context'
 export * from './http/request'
 export * from './http/url'
 export * from './auth/permission-validator'
+export * from './schema/model'
+export * from './schema/json-schema'
+export * from './schema/labels'
+export * from './schema/model-schema'
+export * from './schema/schema-mixin'
+export * from './schema/test/mock-model'
+
+export * from './shared/utils/action-descriptor'
+export * from './shared/utils/schema-utils'