@typetron/framework 0.5.22 → 0.5.24

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

package/Router/Http/Request.ts

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

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