@typetron/framework 0.5.2 → 0.5.3

package/Router/Decorators.ts

@@ -1,224 +0,0 @@
-import { App } from '../Framework'
-import { Abstract, Constructor, Type } from '../Support'
-import { GlobalMiddleware } from './Middleware'
-import { ActionMetadata, ControllerMetadata, ControllerOptions, MethodMetadata, RouteMetadata } from './Metadata'
-import { Guard } from './Guard'
-import { Handler as HttpHandler, Http, Request as HttpRequest } from './Http'
-import { Request } from './Request'
-import { Handler as WebsocketsHandler } from './Websockets'
-import { WebsocketRoute } from './Websockets/WebsocketRoute'
-import { Container } from '@Typetron/Container'
-
-export function Controller(path = '', options?: ControllerOptions) {
-    return (target: object) => {
-        const metadata = ControllerMetadata.get(target)
-        const prefix = options?.prefix || path ? path + '.' : ''
-
-        const httpHandler = Container.getInstance().get(HttpHandler)
-        const websocketHandler = Container.getInstance().get(WebsocketsHandler)
-
-        Object.keys(metadata.routes).forEach(action => {
-            const routeMetadata = metadata.routes[action]
-            const route = httpHandler.addRoute(
-                path + (path && routeMetadata.path ? '/' : '') + routeMetadata.path,
-                routeMetadata.method,
-                target as Constructor,
-                action,
-                prefix + (routeMetadata.name || action),
-                routeMetadata.parametersTypes,
-                metadata.middleware.concat(routeMetadata.middleware)
-            )
-            route.guards = routeMetadata.guards
-        })
-
-        Object.keys(metadata.actions).forEach(actionName => {
-            const actionMetadata = metadata.actions[actionName]
-            const name = prefix + (actionMetadata.name || actionName)
-            const action = websocketHandler.addAction(
-                name,
-                target as Constructor,
-                actionName,
-                actionMetadata.parametersTypes,
-                metadata.middleware.concat(actionMetadata.middleware)
-            )
-            action.guards = actionMetadata.guards
-        })
-    }
-}
-
-function addAction(controller: Constructor, methodName: string, name: string) {
-    const metadata = ControllerMetadata.get(controller)
-
-    const methodMetadata = metadata.methods[methodName]
-    const action = new ActionMetadata()
-    Object.assign(action, methodMetadata)
-
-    action.parametersTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, methodName)
-    action.name = name
-
-    metadata.actions[methodName] = action
-
-    ControllerMetadata.set(metadata, controller)
-}
-
-function addRoute(controller: Constructor, methodName: string, method: Http.Method, path: string, name: string) {
-    const metadata = ControllerMetadata.get(controller)
-
-    const methodMetadata = metadata.methods[methodName]
-    const route = new RouteMetadata()
-    Object.assign(route, methodMetadata)
-
-    route.parametersTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, methodName)
-    route.path = path
-    route.name = name
-    route.method = method
-
-    metadata.routes[methodName] = route
-
-    ControllerMetadata.set(metadata, controller)
-}
-
-export function Action(name = '') {
-    return (target: object, action: string) => {
-        addAction(target.constructor as Constructor, action, name)
-    }
-}
-
-export function OnOpen(target: object, action: string) {
-    const websocketHandler = App.get(WebsocketsHandler)
-
-    websocketHandler.onOpen = new WebsocketRoute(
-        '',
-        target.constructor as Constructor,
-        action,
-        Reflect.getMetadata('design:paramtypes', target, action),
-    )
-}
-
-export function OnClose(target: object, action: string) {
-    const websocketHandler = App.get(WebsocketsHandler)
-
-    websocketHandler.onClose = new WebsocketRoute(
-        '',
-        target.constructor as Constructor,
-        action,
-        Reflect.getMetadata('design:paramtypes', target, action),
-    )
-}
-
-export function Arg(name: string) {
-    return function(target: object, action: string, parameterIndex: number) {
-        // addAction(target.constructor as Constructor, action, name)
-    }
-}
-
-export function Get(path = '', name = '') {
-    return (target: object, action: string) => {
-        addRoute(target.constructor as Constructor, action, Http.Method.GET, path, name)
-    }
-}
-
-export function Post(path: string = '', name = '') {
-    return (target: object, action: string) => {
-        addRoute(target.constructor as Constructor, action, Http.Method.POST, path, name)
-    }
-}
-
-export function Put(path: string = '', name = '') {
-    return (target: object, action: string) => {
-        addRoute(target.constructor as Constructor, action, Http.Method.PUT, path, name)
-    }
-}
-
-export function Patch(path: string = '', name = '') {
-    return (target: object, action: string) => {
-        addRoute(target.constructor as Constructor, action, Http.Method.PATCH, path, name)
-    }
-}
-
-export function Delete(path: string = '', name = '') {
-    return (target: object, action: string) => {
-        addRoute(target.constructor as Constructor, action, Http.Method.DELETE, path, name)
-    }
-}
-
-export function Middleware(...middleware: Abstract<GlobalMiddleware>[]) {
-    return (target: object, action?: string) => {
-        if (action) {
-            target = target.constructor
-        }
-
-        const metadata = ControllerMetadata.get(target)
-
-        if (action) {
-            const route = metadata.methods[action] || new MethodMetadata()
-            route.middleware = route.middleware.concat(middleware)
-            metadata.methods[action] = route
-        } else {
-            metadata.middleware = metadata.middleware.concat(middleware)
-        }
-
-        ControllerMetadata.set(metadata, target)
-    }
-}
-
-export function AllowIf(...guards: Type<Guard>[]) {
-    return function(target: object, action: string) {
-        if (action) {
-            target = target.constructor
-        }
-
-        const metadata = ControllerMetadata.get(target)
-
-        if (action) {
-            const route = metadata.methods[action] || new MethodMetadata()
-            route.guards = route.guards.concat(guards)
-            metadata.methods[action] = route
-        } else {
-            metadata.guards = metadata.guards.concat(guards)
-        }
-
-        ControllerMetadata.set(metadata, target)
-    }
-}
-
-export function Query(name: string) {
-    return function(target: object, action: string, parameterIndex: number) {
-        const metadata = ControllerMetadata.get(target.constructor)
-        const parametersTypes = Reflect.getMetadata('design:paramtypes', target, action)
-
-        const route = metadata.methods[action] || new MethodMetadata()
-        route.parametersOverrides[parameterIndex] = function(container: Container) {
-            const request = container.get(HttpRequest)
-            const value = request.query[name]
-
-            if (parametersTypes[parameterIndex].name === 'Number') {
-                return value === undefined || value === 'undefined' ? undefined : Number(value)
-            }
-            return value
-        }
-
-        metadata.methods[action] = route
-        ControllerMetadata.set(metadata, target.constructor)
-    }
-}
-
-export function Body() {
-    return function(target: object, action: string, parameterIndex: number) {
-        const metadata = ControllerMetadata.get(target.constructor)
-        const route = metadata.methods[action] || new MethodMetadata()
-        route.parametersOverrides[parameterIndex] = function(container: Container) {
-            const request = container.get(Request)
-
-            // TODO: should the framework throw error or return undefined?
-            // if (!request.body) {
-            //     throw new Error(`There is no data in the 'body' of the request`)
-            // }
-
-            return request.body
-        }
-
-        metadata.methods[action] = route
-        ControllerMetadata.set(metadata, target.constructor)
-    }
-}

package/Router/Guard.ts

@@ -1,10 +0,0 @@
-import { Http, HttpError } from './Http'
-
-export abstract class Guard {
-    // tslint:disable-next-line:no-any
-    abstract condition(...args: any[]): Promise<boolean>
-
-    onFail(): void {
-        throw new HttpError('Unauthorized', Http.Status.UNAUTHORIZED)
-    }
-}

package/Router/Http/Contracts.ts

@@ -1,4 +0,0 @@
-export interface Parameters {
-    [key: string]: string | undefined;
-}
-

package/Router/Http/ErrorHandler.ts

@@ -1,45 +0,0 @@
-import { Response } from './Response'
-import { ErrorHandlerInterface } from './ErrorHandlerInterface'
-import { HttpError } from './Errors/HttpError'
-import { Http } from './index'
-import { Request } from './Request'
-import { Inject } from '../../Container'
-import { AppConfig } from '../../Framework/Config'
-
-export class ErrorHandler implements ErrorHandlerInterface {
-
-    @Inject()
-    appConfig: AppConfig
-
-    handle(error: Error, request?: Request) {
-        if (this.appConfig.debug) {
-            return this.handleDevelopmentError(error, request)
-        }
-
-        if (error instanceof HttpError) {
-            return new Response(error.content, error.status)
-        }
-        return new Response(error.message, Http.Status.BAD_REQUEST)
-    }
-
-    private handleDevelopmentError(error: Error, request?: Request) {
-        let code = Http.Status.BAD_REQUEST, message: string | object | number = '', stack: string[]
-
-        stack = error.stack ? error.stack.replace(/\n|\s{2,}/g, '').split('at ') : []
-        if (error instanceof HttpError) {
-            code = error.status
-            message = error.content
-            if (request) {
-                stack.unshift(`Route: ${request.method} ${request.uri}`)
-            }
-        } else {
-            message = error.message
-        }
-
-        const errorInfo: {message: string | object | number, stack?: string[]} = {
-            message, stack
-        }
-
-        return new Response(errorInfo, code)
-    }
-}

package/Router/Http/ErrorHandlerInterface.ts

@@ -1,6 +0,0 @@
-import { Response } from './Response'
-import { Request } from './Request'
-
-export class ErrorHandlerInterface {
-    handle: (error: Error, request?: Request) => Promise<Response> | Response
-}

package/Router/Http/Errors/HttpError.ts

@@ -1,15 +0,0 @@
-import { Http } from '../index'
-
-export class HttpError extends Error {
-
-    constructor(
-        public content: string | object,
-        public status: Http.Status = Http.Status.BAD_REQUEST
-    ) {
-        super(typeof content === 'string' ? content : 'HTTP Error')
-    }
-
-    getMessage() {
-        return this.content
-    }
-}

package/Router/Http/Handler.ts

@@ -1,183 +0,0 @@
-import { Container, Inject } from '../../Container'
-import { RequestHandler, RouteNotFoundError, Router } from '../'
-import { ErrorHandlerInterface, Http, Response } from './'
-import { Request } from './Request'
-import { HttpRoute as Route } from './HttpRoute'
-import { AppConfig } from '../../Framework'
-import { Request as BaseRequest } from '../Request'
-import { Abstract, Constructor, Type } from '@Typetron/Support'
-import { AppServer, nodeServer, uNetworkingServer } from '@Typetron/Router/Servers'
-import { HttpMiddleware } from '@Typetron/Router/Http/Middleware'
-
-const httpServers: Record<AppConfig['server'], AppServer> = {
-    node: nodeServer,
-    uNetworking: uNetworkingServer
-}
-
-export class Handler {
-    @Inject()
-    router: Router
-
-    @Inject()
-    errorHandler: ErrorHandlerInterface
-
-    cachedRoutes: Record<string, [Route, Record<string, string>]> = {}
-
-    addRoute(
-        uri: string,
-        method: Http.Method,
-        controller: Constructor,
-        action: string,
-        name: string,
-        parametersTypes: (Type<(...args: any[]) => any> | FunctionConstructor)[] = [],
-        middleware: Abstract<HttpMiddleware>[] = []
-    ): Route {
-        uri = this.prepareUri(uri)
-        const route = new Route(uri, method, name, controller, action, parametersTypes, middleware)
-        if (this.router.routes.find(item => item.uri === uri && item.method === method)) {
-            throw new Error(`There is already a route with the same url: [${method}] '${uri}'`)
-        }
-        this.router.routes.push(route)
-        return route
-    }
-
-    // async handle(app: Application, request: Request) {
-    //     try {
-    //         return await this.handle(app, request)
-    //     } catch (error) {
-    //         return this.errorHandler.handle(error, request)
-    //     }
-    // }
-
-    startServer(app: Container): void {
-        const config = app.get(AppConfig)
-        const startServer = httpServers[config.server]
-
-        startServer(config.port, async (request) => {
-            try {
-                return await this.handle(app, request)
-            } catch (error) {
-                return this.errorHandler.handle(error as Error)
-            }
-        })
-    }
-
-    async handle(app: Container, request: Request): Promise<Response> {
-        const container = app.createChildContainer()
-
-        container.set(BaseRequest, request)
-        container.set(Request, request)
-
-        let stack: RequestHandler = async () => {
-            const [route, parameters] = this.cachedRoutes[`${request.method} ${request.uri}`]
-            ?? this.findRouteIndex(request.uri ?? '', request.method)
-
-            container.set(Route, route)
-            request.parameters = parameters
-
-            let routeStack: RequestHandler = async () => {
-
-                const content = await route.run(container, request.parameters)
-
-                if (content instanceof Response) {
-                    return content
-                }
-
-                return Response.ok(content)
-            }
-
-            route.middleware.forEach(middlewareClass => {
-                const middleware = container.get(middlewareClass)
-                routeStack = middleware.handle.bind(middleware, request, routeStack)
-            })
-
-            return routeStack(request)
-        }
-
-        this.router.middleware.global?.forEach(middlewareClass => {
-            const middleware = container.get(middlewareClass)
-            stack = middleware.handle.bind(middleware, request, stack)
-        })
-
-        this.router.middleware.http?.forEach(middlewareClass => {
-            const middleware = container.get(middlewareClass)
-            stack = middleware.handle.bind(middleware, request, stack)
-        })
-
-        return stack(request)
-    }
-
-    matches(uri: string, route: Route) {
-        const uriParts = uri.split('/') // ex: ['users', '1', 'posts'];
-        let part
-        let parameterTypeIndex = 0
-        const parameters: Record<string, string> = {}
-        for (part = 0; part < uriParts.length; part++) {
-            if (!route.uriParts[part]) {
-                return false
-            }
-            if (route.uriParts[part].type === 'parameter' && route.hasCorrectPrimitiveType(parameterTypeIndex, uriParts[part])) {
-                parameterTypeIndex++
-                parameters[route.uriParts[part].name] = uriParts[part]
-                continue
-            }
-
-            if (route.uriParts[part].name !== uriParts[part]) {
-                return false
-            }
-        }
-
-        if (part !== route.uriParts.length) {
-            return false
-        }
-        return parameters
-    }
-
-    private findRouteIndex(uri: string, method: string): [Route, Record<string, string> | undefined] {
-        const preparedUri = this.prepareUri(uri)
-
-        for (const route of this.router.routes) {
-            if (route.method.toLowerCase() === method.toLowerCase()) {
-                const parameters = this.matches(preparedUri, route)
-
-                if (parameters) {
-                    this.cachedRoutes[`${method} ${uri}`] = [route, parameters]
-                    return [route, parameters]
-                }
-            }
-        }
-
-        throw new RouteNotFoundError(`[${method}] ${uri}`)
-        // return this.routes
-        //     .where('uri', uri)
-        //     .findWhere('method', method) || this.routeNotFound(uri);
-
-        // const uriParts = uri.split('/'); // ['users', '1', 'posts'];
-        //
-        // let currentRoute: string | undefined;
-        //
-        // let routesGroup = this.routesMap;
-        // uriParts.forEach(part => {
-        //     if (routesGroup[part]) {
-        //         return routesGroup = routesGroup[part];
-        //     }
-        //     if (routesGroup['*']) {
-        //         return routesGroup = routesGroup['*'];
-        //     }
-        //
-        //     throw new Error(`Route for '${uri}' not found`);
-        // });
-
-        // this.routes;
-    }
-
-    private prepareUri(uri: string) {
-        if (uri[0] === '/') {
-            uri = uri.substr(1)
-        }
-        if (uri[uri.length - 1] === '/') {
-            uri = uri.substring(0, uri.length - 1)
-        }
-        return uri
-    }
-}

package/Router/Http/HttpRoute.ts

@@ -1,110 +0,0 @@
-import { Container } from '../../Container'
-import { Abstract, Constructor, Type } from '../../Support'
-import { ControllerMetadata } from './../Metadata'
-import { Route } from '@Typetron/Router'
-import { AnyFunction } from '@Typetron/Support'
-import { HttpMiddleware } from '@Typetron/Router/Http/Middleware'
-
-export class HttpRoute extends Route {
-
-    public readonly uriParts: {name: string, type: 'part' | 'parameter'}[] = []
-
-    constructor(
-        public uri: string,
-        public method: string,
-        public name = '',
-        public controller: Constructor,
-        public controllerMethod: string,
-        public parametersTypes: (Type<AnyFunction> | FunctionConstructor)[] = [],
-        public middleware: Abstract<HttpMiddleware>[] = []
-    ) {
-        super(name, controller, controllerMethod, parametersTypes, middleware)
-        this.splitUriParts()
-    }
-
-    async run(container: Container, requestParameters: Record<string, string | number>): Promise<object | string> {
-        const controller = await container.get(this.controller)
-
-        try {
-            const metadata = ControllerMetadata.get(this.controller).routes[this.controllerMethod]
-            const parameters = await this.resolveParameters(
-                requestParameters,
-                metadata.parametersTypes,
-                metadata.parametersOverrides,
-                container
-            )
-
-            for await (const guardClass of this.guards) {
-                const guard = container.get(guardClass)
-                if (!await guard.condition(...parameters)) {
-                    guard.onFail()
-                }
-            }
-
-            return (controller[this.controllerMethod as keyof Constructor] as AnyFunction<object | string>).apply(controller, parameters)
-        } catch (unknownError) {
-            const error = unknownError as Error
-            error.stack = `Controller: ${controller.constructor.name}.${this.controllerMethod} \n at ` + error.stack
-            throw error
-        }
-    }
-
-    splitUriParts() {
-        this.uri.split('/').forEach(uriPart => {
-            const matches = uriPart.match(/:(\w+)/)
-            if (matches) {
-                this.uriParts.push({
-                    name: matches[1],
-                    type: 'parameter'
-                })
-            } else {
-                this.uriParts.push({
-                    name: uriPart,
-                    type: 'part'
-                })
-            }
-        })
-    }
-
-    getUrl(parameters: Record<string, string>): string {
-        return this.uriParts.map(part => {
-            if (part.type === 'parameter') {
-                return parameters[part.name]
-            }
-            return part.name
-        }).filter(Boolean).join('/')
-    }
-
-    hasCorrectPrimitiveType(parameterTypeIndex: number, uriPart: string) {
-        const parameterType = this.parametersTypes[parameterTypeIndex]
-        return (primitiveTypes[parameterType.name] || (value => value))(uriPart)
-    }
-
-    private async resolveParameters(
-        requestParameters: Record<string, string | number>,
-        parameters: (Type<(...args: any[]) => any> | FunctionConstructor)[],
-        overrides: ((container: Container) => unknown)[],
-        container: Container
-    ) {
-        let parameterIndex = 0
-        const routeParameters = Object.values(requestParameters)
-        return parameters.mapAsync(async (parameter, index) => {
-            const newValueFunction = overrides[index]
-            if (newValueFunction) {
-                return await newValueFunction.call(undefined, container)
-            }
-            if (parameter.name === 'String') {
-                return routeParameters[parameterIndex++]
-            }
-            if (parameter.name === 'Number') {
-                const value = routeParameters[parameterIndex++]
-                return value === undefined || value === 'undefined' ? undefined : Number(value)
-            }
-            return container.get(parameter)
-        })
-    }
-}
-
-const primitiveTypes: Record<string, (value: string) => boolean> = {
-    Number: (value: string) => !isNaN(Number(value)),
-}

package/Router/Http/Middleware.ts

@@ -1,7 +0,0 @@
-import { Request } from '@Typetron/Router/Request'
-import { Response } from '.'
-import { GlobalMiddleware, RequestHandler } from '..'
-
-export abstract class HttpMiddleware extends GlobalMiddleware {
-    abstract handle(request: Request, next: RequestHandler): Promise<Response>
-}