@typetron/framework 0.4.0-rc9 → 0.5.0

package/Router/Decorators.ts

@@ -0,0 +1,224 @@
+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

@@ -0,0 +1,10 @@
+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

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

package/Router/Http/ErrorHandler.ts

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,183 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,7 @@
+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>
+}