@declaro/core 2.0.0-beta.8 → 2.0.0-y.0

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

@@ -1,12 +1,14 @@
-import { EventManager } from './event-manager'
+import { EventManager, type IEvent } from './event-manager'
 import { describe, it, expect, vi } from 'vitest'
 
-class TestEvent {}
+class TestEvent implements IEvent {
+    constructor(public readonly type: string) {}
+}
 
 describe('Event manager', () => {
     it('should add listeners', async () => {
-        const eventManager = new EventManager<TestEvent>()
-        const testEvent = new TestEvent()
+        const eventManager = new EventManager()
+        const testEvent = new TestEvent('test')
 
         const mockListener = vi.fn((event: TestEvent) => {
             expect(event).toBe(testEvent)
@@ -14,14 +16,14 @@ describe('Event manager', () => {
 
         eventManager.on('test', mockListener)
 
-        await eventManager.emitAll('test', testEvent)
+        await eventManager.emitAll(testEvent)
 
         expect(mockListener.mock.calls.length).toBe(1)
     })
 
     it('should remove listeners', async () => {
-        const eventManager = new EventManager<TestEvent>()
-        const testEvent = new TestEvent()
+        const eventManager = new EventManager()
+        const testEvent = new TestEvent('test')
 
         const cb = (event: TestEvent) => {
             expect(event).toBe(testEvent)
@@ -41,7 +43,7 @@ describe('Event manager', () => {
 
         removeListener()
 
-        await eventManager.emitAll('test', testEvent)
+        await eventManager.emitAll(testEvent)
 
         expect(listener1.mock.calls.length).toBe(1)
         expect(listener2.mock.calls.length).toBe(1)
@@ -49,4 +51,48 @@ describe('Event manager', () => {
         expect(listener4.mock.calls.length).toBe(1)
         expect(listener5.mock.calls.length).toBe(1)
     })
+
+    it('should support listening to multiple events', async () => {
+        const eventManager = new EventManager()
+
+        const cb = (event: TestEvent) => {
+            expect(event).toBeInstanceOf(TestEvent)
+        }
+
+        const listener1 = vi.fn(cb)
+        const listener2 = vi.fn(cb)
+
+        eventManager.on(['event-1', 'event-2'], listener1)
+        eventManager.on(['event-3', 'event-4', 'event-5'], listener2)
+
+        await eventManager.emitAll(new TestEvent('event-1'))
+        await eventManager.emitAll(new TestEvent('event-2'))
+        await eventManager.emitAll(new TestEvent('event-3'))
+        await eventManager.emitAll(new TestEvent('event-4'))
+        await eventManager.emitAll(new TestEvent('event-5'))
+
+        expect(listener1.mock.calls.length).toBe(2)
+        expect(listener2.mock.calls.length).toBe(3)
+        expect(eventManager.getEvents().length).toBe(5)
+    })
+
+    it('should be able to subscribe to all events', async () => {
+        const eventManager = new EventManager()
+
+        const cb = (event: TestEvent) => {
+            expect(event).toBeInstanceOf(TestEvent)
+        }
+
+        const listener1 = vi.fn(cb)
+        const listener2 = vi.fn(cb)
+
+        eventManager.on(['*', 'event-1'], listener1) // This should only call the listener once
+        eventManager.on('*', listener2)
+
+        await eventManager.emitAll(new TestEvent('event-1'))
+        await eventManager.emitAll(new TestEvent('event-2'))
+
+        expect(listener1.mock.calls.length).toBe(2)
+        expect(listener2.mock.calls.length).toBe(2)
+    })
 })

package/src/events/event-manager.ts

@@ -1,50 +1,66 @@
-export type Listener = (...args: any[]) => any
+export interface IEvent {
+    type: string
+}
+
+export type Listener = (event: IEvent) => any
 
-export class EventManager<T> {
+export class EventManager<E extends IEvent = IEvent> {
     protected readonly listeners: {
         [key: string]: Listener[]
     } = {}
 
     getListeners(event: string) {
-        this.listeners[event] = Array.isArray(this.listeners[event])
-            ? this.listeners[event]
-            : []
-        return this.listeners[event]
+        const eventListeners = this.getListenerArray(event)
+        const globalListeners = this.listeners['*'] || []
+
+        return [...new Set([...eventListeners, ...globalListeners])]
     }
 
-    on(event: string, listener: Listener) {
-        this.getListeners(event).push(listener)
+    getEvents() {
+        return Object.keys(this.listeners)
+    }
 
-        return () => {
-            const index = this.getListeners(event).indexOf(listener)
-            const willRemove = index > -1
+    on(event: string | string[], listener: Listener) {
+        const events = Array.isArray(event) ? event : [event]
 
-            if (willRemove) {
-                this.getListeners(event).splice(index, 1)
-            }
+        events.forEach((e) => {
+            this.getListenerArray(e).push(listener)
+        })
 
-            return willRemove
+        return () => {
+            events.forEach((e) => {
+                const index = this.getListeners(e).indexOf(listener)
+                if (index > -1) {
+                    this.getListenerArray(e).splice(index, 1)
+                }
+            })
         }
     }
 
-    async emitAsync(event: string, ...args: any[]) {
-        await this.getListeners(event)
+    async emitAsync(event: E) {
+        await this.getListeners(event.type)
             .reduce(async (promise, listener) => {
                 await promise
-                return await listener(...args)
+                return await listener(event)
             }, Promise.resolve())
             .catch((e) => {
                 console.error('Error in event listener', e)
             })
     }
 
-    async emitAll(event: string, ...args: any[]) {
-        await Promise.all(
-            this.getListeners(event).map((listener) => listener(...args)),
-        )
+    async emitAll(event: E) {
+        await Promise.all(this.getListeners(event.type).map((listener) => listener(event)))
+    }
+
+    emit(event: E) {
+        this.getListeners(event.type).forEach((listener) => listener(event))
     }
 
-    emit(event: string, ...args: any[]) {
-        this.getListeners(event).forEach((listener) => listener(...args))
+    protected getListenerArray(event: string) {
+        if (!this.listeners[event]) {
+            this.listeners[event] = []
+        }
+
+        return this.listeners[event]
     }
 }

package/src/http/headers.spec.ts

@@ -0,0 +1,48 @@
+import { Context } from '../context/context'
+import { useHeaders } from './headers'
+import { createRequest } from 'node-mocks-http'
+import { provideRequest } from './request'
+import { describe, expect, it } from 'vitest'
+
+describe('Http Headers', () => {
+    const request = createRequest({
+        method: 'GET',
+        url: 'https://example.com/test',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Test': 'test',
+            Authorization: 'Bearer 123',
+        },
+    })
+
+    it('Should get an empty object by default', () => {
+        const context = new Context()
+
+        const headers = useHeaders(context)
+
+        expect(Object.keys(headers).length).toEqual(0)
+    })
+
+    // Provide some sample headers
+    it('Should provide headers', () => {
+        const context = new Context()
+
+        provideRequest(context, request)
+
+        const headers = useHeaders(context)
+
+        expect(headers['content-type']).toEqual('application/json')
+        expect(headers['x-test']).toEqual('test')
+        expect(headers['authorization']).toEqual('Bearer 123')
+    })
+
+    it('Should use a single header', () => {
+        const context = new Context()
+
+        provideRequest(context, request)
+
+        const headers = useHeaders(context)
+
+        expect(headers['content-type']).toEqual('application/json')
+    })
+})

package/src/http/headers.ts

@@ -0,0 +1,16 @@
+import { Context } from '../context/context'
+import { useRequest } from './request'
+
+export type HeaderMap = Record<string, string>
+
+export function useHeaders(context: Context) {
+    const request = useRequest(context)
+
+    return request?.headers ?? {}
+}
+
+export function useHeader(context: Context, header: string) {
+    const headers = useHeaders(context)
+
+    return headers[header]
+}

package/src/http/request-context.spec.ts

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { Context, type ContextMiddleware } from '../context/context'
+import { provideRequestMiddleware, useRequestMiddleware } from './request-context'
+
+describe('Http Request Context', () => {
+    let context: Context
+
+    beforeEach(() => {
+        context = new Context()
+    })
+
+    it('Should have nothing by default', () => {
+        const initialMiddleware = useRequestMiddleware(context)
+        expect(initialMiddleware.length).toEqual(0)
+    })
+
+    it('Should provide a middleware', () => {
+        const middleware1: ContextMiddleware = (context) => {
+            context.provide('test', 'test')
+        }
+        const middleware2: ContextMiddleware = (context) => {
+            context.provide('test2', 'test2')
+        }
+
+        provideRequestMiddleware(context, middleware1, middleware2)
+
+        const mwList = useRequestMiddleware(context)
+
+        expect(mwList.length).toEqual(2)
+
+        mwList.forEach((mw) => mw(context))
+
+        const val1 = context.inject('test')
+        const val2 = context.inject('test2')
+
+        expect(val1).toEqual('test')
+        expect(val2).toEqual('test2')
+    })
+})

package/src/http/request-context.ts

@@ -0,0 +1,43 @@
+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)
+
+    return middleware ?? []
+}
+
+export function provideRequestMiddleware(context: Context, ...middleware: ContextMiddleware[]) {
+    const existingMiddleware = useRequestMiddleware(context)
+
+    const extendedMiddleware = [...existingMiddleware, ...middleware]
+
+    context.provide(REQUEST_CONTEXT_MIDDLEWARE, extendedMiddleware)
+
+    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)
+
+    return middleware ?? []
+}
+
+export function provideNodeMiddleware(context: Context, ...middleware: AllNodeMiddleware[]) {
+    const existingMiddleware = useNodeMiddleware(context)
+
+    const extendedMiddleware = [...existingMiddleware, ...middleware]
+
+    context.provide(REQUEST_NODE_MIDDLEWARE, extendedMiddleware)
+
+    return extendedMiddleware
+}

package/src/http/request.spec.ts

@@ -0,0 +1,52 @@
+import { Context } from '../context/context'
+import { createRequest } from 'node-mocks-http'
+import { provideRequest, useRequest, useRequestMethod } from './request'
+import { describe, expect, it } from 'vitest'
+
+describe('Http Request', () => {
+    it('Should get undefined by default', () => {
+        const context = new Context()
+
+        const request = useRequest(context)
+
+        expect(request).toBeUndefined()
+    })
+    it('Should provide a request', () => {
+        const context = new Context()
+
+        const request = createRequest({
+            method: 'GET',
+            url: '/test',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Test': 'test',
+                Authorization: 'Bearer 123',
+            },
+        })
+
+        provideRequest(context, request)
+
+        const request2 = useRequest(context)
+
+        expect(request2).toEqual(request)
+    })
+
+    it('Should get the method', () => {
+        const context = new Context()
+
+        const request = createRequest({
+            method: 'GET',
+            url: '/test',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Test': 'test',
+            },
+        })
+
+        provideRequest(context, request)
+
+        const method = useRequestMethod(context)
+
+        expect(method).toEqual('GET')
+    })
+})

package/src/http/request.ts

@@ -0,0 +1,22 @@
+import { Context } from '../context/context'
+import type { IncomingMessage } from 'http'
+
+export const REQUEST = Symbol('declaro:request')
+
+export interface Request extends IncomingMessage {}
+
+export function provideRequest(context: Context, request: Request) {
+    context.provide(REQUEST, request)
+}
+
+export function useRequest(context: Context) {
+    const request = context.inject<Request | undefined>(REQUEST)
+
+    return request
+}
+
+export function useRequestMethod(context: Context) {
+    const request = useRequest(context)
+
+    return request?.method
+}

package/src/http/url.spec.ts

@@ -0,0 +1,87 @@
+// Tests for url.ts:
+// Create tests for the following functions:
+// - useURL: make sure it returns undefined by default, and the URL object if provided
+// - provideURL: make sure you can provide a URL object or a string
+// - useURLString: make sure it returns the stringified URL
+// - useURLDomain: make sure it returns the domain part of the URL provided
+// - useURLPath
+
+import { Context } from '../context/context'
+import { useRequestDomain, useRequestPath, useRequestQuery, useRequestURL, useRequestURLString } from './url'
+import { provideRequest } from './request'
+import { createRequest } from 'node-mocks-http'
+import { describe, expect, it } from 'vitest'
+
+// - useURLQueryString
+describe('Http URL', () => {
+    const testUrlString = 'https://example.com/test?a=1&b=2'
+    const testUrlObject = new URL(testUrlString)
+    const request = createRequest({
+        method: 'GET',
+        url: testUrlString,
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Test': 'test',
+            Authorization: 'Bearer 123',
+        },
+    })
+
+    it('Should get undefined by default', () => {
+        const context = new Context()
+
+        const url = useRequestURL(context)
+
+        expect(url).toBeUndefined()
+    })
+
+    it('Should get the URL object if provided', () => {
+        const context = new Context()
+
+        provideRequest(context, request)
+
+        const url2 = useRequestURL(context)
+
+        expect(url2).toEqual(testUrlObject)
+    })
+
+    it('Should get the stringified URL', () => {
+        const context = new Context()
+
+        provideRequest(context, request)
+
+        const url2 = useRequestURLString(context)
+
+        expect(url2).toEqual(testUrlString)
+    })
+
+    it('Should get the domain part of the URL', () => {
+        const context = new Context()
+
+        provideRequest(context, request)
+
+        const domain = useRequestDomain(context)
+
+        expect(domain).toEqual('example.com')
+    })
+
+    it('Should get the path part of the URL', () => {
+        const context = new Context()
+
+        provideRequest(context, request)
+
+        const path = useRequestPath(context)
+
+        expect(path).toEqual('/test')
+    })
+
+    it('Should get the query string part of the URL', () => {
+        const context = new Context()
+
+        provideRequest(context, request)
+
+        const query = useRequestQuery(context)
+
+        expect(query['a']).toEqual('1')
+        expect(query['b']).toEqual('2')
+    })
+})

package/src/http/url.ts

@@ -0,0 +1,48 @@
+import { Context } from '../context/context'
+import { URL } from 'whatwg-url'
+import { useRequest } from './request'
+
+export function useRequestURL(context: Context) {
+    const request = useRequest(context)
+    const url = request?.url && new URL(request?.url)
+
+    return url
+}
+
+export function useRequestURLString(context: Context) {
+    const url = useRequestURL(context)
+
+    return url?.toString()
+}
+
+export function useRequestDomain(context: Context) {
+    const url = useRequestURL(context)
+
+    return url?.hostname
+}
+
+export function useRequestPath(context: Context) {
+    const url = useRequestURL(context)
+
+    return url?.pathname
+}
+
+export function useRequestQuery(context: Context): Record<string, string> {
+    const url = useRequestURL(context)
+
+    const qs = url?.searchParams
+
+    // convert qs to an object of key value pairs
+    const qsMap = [...qs?.entries()].reduce((qsMap, [key, value]) => {
+        qsMap[key] = value
+        return qsMap
+    }, {} as Record<string, string>)
+
+    return qsMap
+}
+
+export function useFormattedQueryParam(context: Context, key: string) {
+    const qs = useRequestQuery(context)
+
+    const value = qs[key]
+}

package/src/index.ts

@@ -1,13 +1,19 @@
 export * from './typescript'
 export * from './app'
-export * from './server'
-export * from './context'
+export * from './context/context'
+export * from './context/context-consumer'
+export * from './context/validators'
 export * from './dataflow'
 export * from './events'
 export * from './validation'
 export * from './timing'
 export * from './schema'
 export * from './helpers'
-export * from './interfaces'
+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'