@typetron/framework 0.5.20 → 0.5.22

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>
+}

package/Router/Http/Request.ts

@@ -0,0 +1,225 @@
+import { IncomingHttpHeaders, IncomingMessage } from 'http'
+import { Http } from '.'
+import { Parameters } from './Contracts'
+import * as querystring from 'querystring'
+import { ParsedUrlQuery } from 'querystring'
+import { File } from '../../Storage'
+import busboy, { FileInfo } from 'busboy'
+import * as os from 'os'
+import * as fs from 'fs'
+import * as Url from 'fast-url-parser'
+import { Readable } from 'stream'
+import { Request as BaseRequest } from '@Typetron/Router/Request'
+
+const cacheURLs = new Array<{url: string, instance: URL}>(100)
+
+export class Request extends BaseRequest {
+    // static methodField = '_method'
+
+    public parameters: Record<string, string | number> = {}
+
+    declare protected raw: BaseRequest['raw'] & {
+        urlOrUri: string,
+        method: Http.Method,
+        query?: string | ParsedUrlQuery,
+    }
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    protected details: BaseRequest['details'] & {
+        url: string,
+        uri: string,
+        method: Http.Method,
+        query: ParsedUrlQuery,
+    } = {}
+
+    getHeader: <T extends string | string[]>(name: keyof IncomingHttpHeaders | string) => T | undefined
+
+    constructor(
+        urlOrUri: string,
+        method: Http.Method,
+        query?: string | ParsedUrlQuery,
+        cookies?: string | Parameters,
+        body?: string | object,
+        files?: Record<string, File | File[]>,
+    ) {
+        super(urlOrUri, body, cookies, files)
+        this.raw.urlOrUri = urlOrUri
+        this.raw.method = method
+        this.raw.query = query
+    }
+
+    get headers(): IncomingHttpHeaders {
+        return {}
+    }
+
+    get url(): string {
+        return this.details.url ?? (() => {
+            const url = Url.parse(this.raw.urlOrUri)
+            return this.details.url = url.format()
+        })()
+    }
+
+    get uri(): string {
+        return this.details.uri ?? (() => {
+            const url = cacheURLs[this.raw.urlOrUri.length]?.url === this.raw.urlOrUri
+                ? cacheURLs[this.raw.urlOrUri.length].instance
+                : (() => {
+                    cacheURLs[this.raw.urlOrUri.length] = {
+                        url: this.raw.urlOrUri,
+                        instance: Url.parse(this.raw.urlOrUri)
+                    }
+                    return cacheURLs[this.raw.urlOrUri.length].instance
+                })()
+
+            return this.details.uri = url.pathname ?? ''
+        })()
+    }
+
+    get method(): Http.Method {
+        return this.raw.method
+    }
+
+    get query(): ParsedUrlQuery {
+        return this.details.query ?? (() => {
+            return this.details.query = typeof this.raw.query === 'object'
+                ? this.raw.query
+                : querystring.parse(
+                    typeof this.raw.query === 'string'
+                        ? this.raw.query
+                        : Url.parse(this.raw.urlOrUri).query ?? ''
+                )
+        })()
+    }
+
+    get body() {
+        return this.details.body ?? (() => {
+            return this.details.body = this.raw.body
+        })()
+    }
+
+    get cookies(): Parameters {
+        return this.details.cookies ?? (() => {
+            return {todo: 'parse cookies'}
+        })()
+    }
+
+    static async loadMultipartContent(incomingMessage: IncomingMessage): Promise<[string | object, Record<string, File | File[]>]> {
+
+        return new Promise((resolve, reject) => {
+            const formDataParser = busboy({headers: incomingMessage.headers})
+            const files: Record<string, File | File[]> = {}
+            const content: Record<string, string> = {}
+
+            formDataParser.on('file', function(fieldName: string, file: Readable, {filename, encoding, mimeType}: FileInfo) {
+                const extension = filename.split('.').pop()
+                const fileInstance = new File(`upload_${new Date().getTime().toString()}_${String.randomAlphaNum(9)}.${extension}`)
+
+                fileInstance.originalName = filename
+                fileInstance.directory = os.tmpdir()
+                fileInstance.saved = true
+
+                const stream = fs.createWriteStream(fileInstance.path)
+                stream.on('error', reject)
+
+                file.on('data', function(data) {
+                    stream.write(data)
+                })
+                file.on('end', function() {
+                    stream.end()
+
+                    const field = files[fieldName]
+                    files[fieldName] = field instanceof Array ? [...field, fileInstance] : field ? [field, fileInstance] : fileInstance
+                })
+            })
+            formDataParser.on('field', function(fieldName, value) {
+                content[fieldName] = value
+            })
+            formDataParser.on('finish', function() {
+                resolve([content, files])
+            })
+
+            incomingMessage.pipe(formDataParser)
+        })
+    }
+
+    set body(body: string | object | undefined) {
+        this.details.body = body
+    }
+
+    get files() {
+        return this.raw.files ?? {}
+    }
+
+    set files(files: Record<string, File | File[]>) {
+        this.raw.files = files
+    }
+
+    // static async capture(message: IncomingMessage): Promise<Request> {
+    //     const request = new this(
+    //         message.url ?? '',
+    //         message.method as Http.Method || Http.Method.GET,
+    //         message.headers
+    //     )
+    //
+    //     if (request.method !== Http.Method.GET) {
+    //         if (this.isMultipartRequest(message)) {
+    //             [request.body, request.files] = await Request.loadMultipartContent(message)
+    //         } else {
+    //             request.body = await Request.loadSimpleContent(message)
+    //         }
+    //
+    //         // const overwrittenMethod = (request.body as Record<string, string | undefined>)[Request.methodField] || ''
+    //         // request.method = Http.Method[overwrittenMethod.toUpperCase() as Http.Method] || request.method
+    //     }
+    //
+    //     return request
+    // }
+
+    private static isJSONRequest(incomingMessage: IncomingMessage): boolean {
+        return Boolean(incomingMessage.headers['content-type']?.includes('application/json'))
+    }
+
+    static async loadSimpleContent(incomingMessage: IncomingMessage): Promise<string | object | undefined> {
+        let rawData = ''
+        incomingMessage.on('data', chunk => {
+            rawData += chunk
+        })
+
+        return new Promise((resolve, reject) => {
+            incomingMessage.on('end', async () => {
+                try {
+                    if (this.isJSONRequest(incomingMessage)) {
+                        try {
+                            return resolve(JSON.parse(rawData))
+                        } catch (error) {
+                            resolve({})
+                        }
+                    }
+
+                    resolve(rawData)
+                } catch (error) {
+                    if (error instanceof SyntaxError) {
+                        error.stack = `Value used: '${rawData}'\n at ` + error.stack
+                        reject(error)
+                    }
+                    resolve(rawData ? rawData : undefined)
+                }
+            })
+        })
+    }
+
+    setHeadersLoader(loader: () => IncomingHttpHeaders): void {
+        Object.defineProperty(this, 'headers', {
+            get: function() {
+                return loader()
+            },
+            enumerable: true,
+            configurable: true
+        })
+    }
+
+    isMultipartRequest() {
+        return Boolean(this.getHeader('content-type')?.includes('multipart/form-data'))
+    }
+}

package/Router/Http/Response.ts

@@ -0,0 +1,35 @@
+import { OutgoingHttpHeaders } from 'http'
+import { Http } from '.'
+import { Buffer } from 'buffer'
+
+type Content = unknown | undefined | number | string | object | Buffer
+
+export class Response<T = unknown> {
+
+    constructor(
+        public body: T,
+        public status: Http.Status = Http.Status.OK,
+        public headers: OutgoingHttpHeaders = {}
+    ) {
+    }
+
+    static ok(content: string | object) {
+        return new Response(content, Http.Status.OK)
+    }
+
+    static notFound(content: string | object) {
+        return new Response(content, Http.Status.NOT_FOUND)
+    }
+
+    static badRequest(content: string | object) {
+        return new Response(content, Http.Status.BAD_REQUEST)
+    }
+
+    setHeader(name: string, value: string) {
+        this.headers[name] = value
+    }
+
+    setHeaders(headers: OutgoingHttpHeaders) {
+        this.headers = headers
+    }
+}