@typetron/framework 0.5.22 → 0.5.24

package/Router/Http/index.ts

@@ -1,85 +0,0 @@
-export namespace Http {
-    export enum Method {
-        GET = 'GET',
-        HEAD = 'HEAD',
-        POST = 'POST',
-        PUT = 'PUT',
-        PATCH = 'PATCH',
-        DELETE = 'DELETE',
-        OPTIONS = 'OPTIONS',
-    }
-
-    export enum Status {
-        CONTINUE = 100,
-        SWITCHING_PROTOCOLS = 101,
-        PROCESSING = 102, // RFC2518
-        EARLY_HINTS = 103, // RFC8297
-        OK = 200,
-        CREATED = 201,
-        ACCEPTED = 202,
-        NON_AUTHORITATIVE_INFORMATION = 203,
-        NO_CONTENT = 204,
-        RESET_CONTENT = 205,
-        PARTIAL_CONTENT = 206,
-        MULTI_STATUS = 207, // RFC4918
-        ALREADY_REPORTED = 208, // RFC5842
-        IM_USED = 226, // RFC3229
-        MULTIPLE_CHOICES = 300,
-        MOVED_PERMANENTLY = 301,
-        FOUND = 302,
-        SEE_OTHER = 303,
-        NOT_MODIFIED = 304,
-        USE_PROXY = 305,
-        RESERVED = 306,
-        TEMPORARY_REDIRECT = 307,
-        PERMANENTLY_REDIRECT = 308, // RFC7238
-        BAD_REQUEST = 400,
-        UNAUTHORIZED = 401,
-        PAYMENT_REQUIRED = 402,
-        FORBIDDEN = 403,
-        NOT_FOUND = 404,
-        METHOD_NOT_ALLOWED = 405,
-        NOT_ACCEPTABLE = 406,
-        PROXY_AUTHENTICATION_REQUIRED = 407,
-        REQUEST_TIMEOUT = 408,
-        CONFLICT = 409,
-        GONE = 410,
-        LENGTH_REQUIRED = 411,
-        PRECONDITION_FAILED = 412,
-        REQUEST_ENTITY_TOO_LARGE = 413,
-        REQUEST_URI_TOO_LONG = 414,
-        UNSUPPORTED_MEDIA_TYPE = 415,
-        REQUESTED_RANGE_NOT_SATISFIABLE = 416,
-        EXPECTATION_FAILED = 417,
-        I_AM_A_TEAPOT = 418, // RFC2324
-        MISDIRECTED_REQUEST = 421, // RFC7540
-        UNPROCESSABLE_ENTITY = 422, // RFC4918
-        LOCKED = 423, // RFC4918
-        FAILED_DEPENDENCY = 424, // RFC4918
-        RESERVED_FOR_WEBDAV_ADVANCED_COLLECTIONS_EXPIRED_PROPOSAL = 425, // RFC2817
-        TOO_EARLY = 425, // RFC-ietf-httpbis-replay-04
-        UPGRADE_REQUIRED = 426, // RFC2817
-        PRECONDITION_REQUIRED = 428, // RFC6585
-        TOO_MANY_REQUESTS = 429, // RFC6585
-        REQUEST_HEADER_FIELDS_TOO_LARGE = 431, // RFC6585
-        UNAVAILABLE_FOR_LEGAL_REASONS = 451,
-        INTERNAL_SERVER_ERROR = 500,
-        NOT_IMPLEMENTED = 501,
-        BAD_GATEWAY = 502,
-        SERVICE_UNAVAILABLE = 503,
-        GATEWAY_TIMEOUT = 504,
-        VERSION_NOT_SUPPORTED = 505,
-        VARIANT_ALSO_NEGOTIATES_EXPERIMENTAL = 506, // RFC2295
-        INSUFFICIENT_STORAGE = 507, // RFC4918
-        LOOP_DETECTED = 508, // RFC5842
-        NOT_EXTENDED = 510, // RFC2774
-        NETWORK_AUTHENTICATION_REQUIRED = 511, // RFC6585
-    }
-}
-
-export * from './ErrorHandler'
-export * from './ErrorHandlerInterface'
-export * from './Handler'
-export * from './Request'
-export * from './Response'
-export * from './Errors/HttpError'

package/Router/Metadata.ts

@@ -1,34 +0,0 @@
-import { MetadataKey } from '../Support/Metadata'
-import { Abstract, Type } from '../Support'
-import { MiddlewareInterface } from './Middleware'
-import { Http } from './Http'
-import { Guard } from './Guard'
-import { Container } from '@Typetron/Container'
-
-export class MethodMetadata {
-    middleware: Abstract<MiddlewareInterface>[] = []
-    parametersTypes: (Type<(...args: any[]) => any> | FunctionConstructor)[]
-    name: string
-    parametersOverrides: ((container: Container) => any)[] = []
-    guards: typeof Guard[] = []
-}
-
-export class ActionMetadata extends MethodMetadata {
-}
-
-export class RouteMetadata extends MethodMetadata {
-    path: string
-    method: Http.Method
-}
-
-export class ControllerOptions {
-    prefix?: string
-}
-
-export class ControllerMetadata extends MetadataKey('framework:controller') {
-    middleware: Abstract<MiddlewareInterface>[] = []
-    routes: {[key: string]: RouteMetadata} = {}
-    actions: {[key: string]: ActionMetadata} = {}
-    methods: {[key: string]: MethodMetadata} = {}
-    guards: typeof Guard[] = []
-}

package/Router/Middleware.ts

@@ -1,16 +0,0 @@
-import { Response } from './Http'
-import { Request } from '@Typetron/Router/Request'
-
-export type RequestHandler = (request: Request) => Promise<Response>
-
-/**
- * @deprecated Please use the Middleware, HttpMiddleware or WebsocketMiddleware classes instead
- */
-export type MiddlewareInterface = {
-    handle(request: Request, next: RequestHandler): Promise<Response>
-}
-
-export abstract class GlobalMiddleware {
-    abstract handle(request: Request, next: RequestHandler): Promise<Response>
-}
-

package/Router/Request.ts

@@ -1,65 +0,0 @@
-import { File } from '../Storage'
-
-export class Request {
-    public parameters: Record<string, string | number> = {}
-
-    protected raw: {
-        name: string,
-        body?: string | object,
-        cookies?: Record<string, string | undefined> | string,
-        files?: Record<string, File | File[]>,
-    }
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    protected details: {
-        name: string,
-        body: string | object | undefined,
-        cookies: Record<string, string | undefined>,
-        files: Record<string, File | File[]>,
-    } = {}
-
-    constructor(
-        name: string,
-        body?: string | object,
-        cookies?: string | Record<string, string | undefined>,
-        files?: Record<string, File | File[]>,
-    ) {
-        this.raw = {
-            name,
-            cookies,
-            body,
-            files,
-        }
-    }
-
-    get name(): string {
-        return this.details.name ?? (() => {
-            return this.details.name = this.raw.name
-        })()
-    }
-
-    get body() {
-        return this.details.body ?? (() => {
-            return this.details.body = this.raw.body
-        })()
-    }
-
-    set body(body: string | object | undefined) {
-        this.details.body = body
-    }
-
-    get cookies(): Record<string, string | undefined> {
-        return this.details.cookies ?? (() => {
-            return {todo: 'parse cookies'}
-        })()
-    }
-
-    get files() {
-        return this.raw.files ?? {}
-    }
-
-    set files(files: Record<string, File | File[]>) {
-        this.raw.files = files
-    }
-}

package/Router/Route.ts

@@ -1,16 +0,0 @@
-import { Abstract, AnyFunction, Constructor, Type } from '../Support'
-import { GlobalMiddleware } from './Middleware'
-import { Guard } from './Guard'
-
-export abstract class Route {
-    guards: (typeof Guard)[] = []
-
-    constructor(
-        public name = '',
-        public controller: Constructor,
-        public controllerMethod: string,
-        public parametersTypes: (Type<AnyFunction> | FunctionConstructor)[] = [],
-        public middleware: Abstract<GlobalMiddleware>[] = []
-    ) {
-    }
-}

package/Router/RouteNotFoundError.ts

@@ -1,5 +0,0 @@
-export class RouteNotFoundError extends Error {
-    constructor(path: string) {
-        super(`Route '${path}' not found`)
-    }
-}

package/Router/Router.ts

@@ -1,35 +0,0 @@
-import { Container, Inject } from '../Container'
-import { Storage } from '../Storage'
-import { Abstract } from '../Support'
-import { GlobalMiddleware } from './Middleware'
-import { WebsocketRoute } from './Websockets/WebsocketRoute'
-import { HttpRoute } from '@Typetron/Router/Http/HttpRoute'
-import { HttpMiddleware } from '@Typetron/Router/Http/Middleware'
-import { WebsocketMiddleware } from '@Typetron/Router/Websockets/Middleware'
-
-export class Router {
-
-    @Inject()
-    app: Container
-
-    routes: HttpRoute[] = []
-    actions = new Map<string, WebsocketRoute>()
-
-    middleware: {
-        global: Abstract<GlobalMiddleware>[],
-        http: Abstract<HttpMiddleware>[],
-        websocket: Abstract<WebsocketMiddleware>[],
-    } = {
-        global: [],
-        http: [],
-        websocket: [],
-    }
-
-    public loadControllers(directory: string) {
-        this.app.get(Storage)
-            .files(directory, true)
-            .whereIn('extension', ['ts'])
-            .forEach(file => require(file.path))
-    }
-
-}

package/Router/Servers/index.ts

@@ -1,6 +0,0 @@
-import { Request, Response } from '@Typetron/Router/Http'
-
-export * from './node'
-export * from './uNetworking'
-
-export type AppServer = (port: number, handler: (request: Request) => Promise<Response>) => void

package/Router/Servers/node.ts

@@ -1,49 +0,0 @@
-import { Http, Request, Response } from '@Typetron/Router/Http'
-import { createServer, IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http'
-import { Buffer } from 'buffer'
-
-export function nodeServer(port: number, handler: (request: Request) => Promise<Response>) {
-    const server = createServer(async (incomingMessage: IncomingMessage, serverResponse: ServerResponse) => {
-        const request = new Request(
-            incomingMessage.url ?? '',
-            incomingMessage.method as Http.Method || Http.Method.GET
-        )
-
-        request.setHeadersLoader(() => incomingMessage.headers)
-        request.getHeader = <T extends string | string[] | undefined>(name: keyof IncomingHttpHeaders | string): T => {
-            return incomingMessage.headers[String(name).toLowerCase()] as T
-        }
-
-        if (request.method.toLowerCase() !== Http.Method.GET.toLowerCase()) {
-            if (request.isMultipartRequest()) {
-                [request.body, request.files] = await Request.loadMultipartContent(incomingMessage)
-            } else {
-                request.body = await Request.loadSimpleContent(incomingMessage)
-            }
-
-            // const overwrittenMethod = (request.body as Record<string, string | undefined>)[Request.methodField] || ''
-            // request.method = Http.Method[overwrittenMethod.toUpperCase() as Http.Method] || request.method
-        }
-
-        const response = await handler(request)
-
-        let content = response.body
-
-        if (!(content instanceof Buffer)) {
-            if (content instanceof Object) {
-                content = JSON.stringify(content)
-                serverResponse.setHeader('Content-Type', 'application/json')
-            }
-            content = String(content ?? '')
-        }
-
-        for (const header in response.headers) {
-            serverResponse.setHeader(header, response.headers[header] || '')
-        }
-
-        serverResponse.statusCode = response.status
-        serverResponse.end(content)
-    })
-
-    server.listen(port)
-}

package/Router/Servers/uNetworking.ts

@@ -1,151 +0,0 @@
-import { App, HttpRequest, HttpResponse } from 'uWebSockets.js'
-import { Http, Request, Response } from '@Typetron/Router/Http'
-import { Buffer } from 'buffer'
-import { IncomingHttpHeaders } from 'http'
-import * as console from 'console'
-import busboy, { FileInfo } from 'busboy'
-import { File } from '@Typetron/Storage'
-import { Readable } from 'stream'
-import os from 'os'
-import fs from 'fs'
-
-async function handleRequest(serverResponse: HttpResponse, serverRequest: HttpRequest, handler: (request: Request) => Promise<Response>) {
-    serverResponse.onAborted(() => {
-        console.log('uNetworking response aborted ->', serverResponse)
-    })
-
-    try {
-        const request = new Request(serverRequest.getUrl(), serverRequest.getMethod() as Http.Method, serverRequest.getQuery())
-        const headers: Record<string, string> = {}
-
-        serverRequest.forEach((name, value) => headers[name] = value)
-        request.setHeadersLoader(() => headers)
-        request.getHeader = <T extends string | string[] | undefined>(name: keyof IncomingHttpHeaders | string): T => {
-            return serverRequest.getHeader(name.toString()) as T
-        }
-
-        if (request.method.toLowerCase() !== Http.Method.GET.toLowerCase()) {
-            if (request.isMultipartRequest()) {
-                [request.body, request.files] = await readForm(serverResponse, headers)
-            } else {
-                request.body = await readJson(serverResponse, headers['content-type'])
-            }
-
-            // const overwrittenMethod = (request.body as Record<string, string | undefined>)[Request.methodField] || ''
-            // request.method = Http.Method[overwrittenMethod.toUpperCase() as Http.Method] || request.method
-        }
-
-        const response = await handler(request)
-        let content = response.body as string | object | number | Array<any> | Buffer
-
-        serverResponse.writeStatus(response.status.toString())
-
-        if (!(content instanceof Buffer)) {
-            if (content instanceof Object) {
-                content = JSON.stringify(content)
-                serverResponse.writeHeader('Content-Type', 'application/json')
-            }
-            content = String(content ?? '')
-        }
-
-        Object.keys(response.headers).forEach(header => {
-            const headerValue = response.headers[header]
-            if (headerValue) {
-                serverResponse.writeHeader(header, String(headerValue))
-            }
-        })
-        serverResponse.end(content)
-    } catch (error) {
-        console.log('error ->', error)
-    }
-}
-
-export function uNetworkingServer(port: number, handler: (request: Request) => Promise<Response>) {
-    const app = App({ // or maybe SSLApp?
-        // key_file_name: 'misc/key.pem',
-        // cert_file_name: 'misc/cert.pem',
-        // passphrase: '1234'
-    })
-        .any('*', async (response, request) => {
-            await handleRequest(response, request, handler)
-        })
-        .any('/*', async (response, request) => {
-            await handleRequest(response, request, handler)
-        })
-        .listen(port, (token) => {
-            if (!token) {
-                console.log('Failed to listen to port ' + port)
-            }
-        })
-}
-
-/* Helper function for reading a posted JSON body */
-function readJson(response: HttpResponse, contentType: string) {
-    let buffer: Buffer
-    return new Promise<object | string | undefined>((resolve, reject) => {
-        response.onData((ab, isLast) => {
-            const chunk = Buffer.from(ab)
-            if (!isLast) {
-                buffer = Buffer.concat(buffer ? [buffer, chunk] : [chunk])
-                return
-            }
-
-            const content = (buffer ? Buffer.concat([buffer, chunk]) : chunk)
-            if (contentType === 'application/json') {
-                try {
-                    const json = JSON.parse(content.toString())
-                    resolve(json)
-                } catch (e) {
-                    resolve({})
-                }
-            } else {
-                resolve(content)
-            }
-
-        })
-    })
-}
-
-function readForm(response: HttpResponse, headers: any): Promise<[string | object, Record<string, File | File[]>]> {
-    return new Promise((resolve, reject) => {
-        const formDataParser = busboy({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])
-        })
-
-        response.onData((ab, isLast) => {
-            formDataParser.write(Buffer.from(ab.slice(0)))
-            if (isLast) {
-                formDataParser.end()
-            }
-        })
-    })
-
-}

package/Router/Websockets/Handler.ts

@@ -1,82 +0,0 @@
-import { Container, Inject } from '../../Container'
-import { RequestHandler, Router } from '../../Router'
-import { Response } from '../Http'
-import { Request as BaseRequest } from '../Request'
-import { Abstract, Constructor, Type } from '../../Support'
-import { WebsocketRoute } from './WebsocketRoute'
-import { Request } from '@Typetron/Router/Websockets/Request'
-import { WebsocketMiddleware } from '@Typetron/Router/Websockets/Middleware'
-
-export class Handler {
-    @Inject()
-    router: Router
-
-    onOpen?: WebsocketRoute
-    onClose?: WebsocketRoute
-
-    addAction(
-        name: string,
-        controller: Constructor,
-        actionName: string,
-        parametersTypes: (Type<(...args: any[]) => any> | FunctionConstructor)[] = [],
-        middleware: Abstract<WebsocketMiddleware>[] = []
-    ) {
-        const action = new WebsocketRoute(
-            name,
-            controller,
-            actionName,
-            parametersTypes,
-            middleware
-        )
-        if (this.router.actions.has(name)) {
-            throw new Error(`There is already an action with the same name: '${name}'`)
-        }
-        this.router.actions.set(name, action)
-        return action
-    }
-
-    async handle<T = unknown>(container: Container, request: Request): Promise<Response<T>> {
-
-        container.set(BaseRequest, request)
-        container.set(Request, request)
-
-        let stack: RequestHandler = async () => {
-            const route = this.router.actions.get(request.name)
-
-            if (!route) {
-                throw new Error(`Action '${request.name}' not found`)
-            }
-
-            container.set(WebsocketRoute, route)
-
-            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 await routeStack(request)
-        }
-
-        this.router.middleware.global?.forEach(middlewareClass => {
-            const middleware = container.get(middlewareClass)
-            stack = middleware.handle.bind(middleware, request, stack)
-        })
-
-        await this.router.middleware.websocket?.forEachAsync(async middlewareClass => {
-            const middleware = await container.get(middlewareClass)
-            stack = middleware.handle.bind(middleware, request, stack)
-        })
-
-        return await stack(request) as Response<T>
-    }
-}

package/Router/Websockets/Middleware.ts

@@ -1,7 +0,0 @@
-import { Request } from '@Typetron/Router/Websockets/Request'
-import { GlobalMiddleware, RequestHandler } from '@Typetron/Router'
-import { Response } from '@Typetron/Router/Http' // TODO remove any Http reference from websockets
-
-export abstract class WebsocketMiddleware extends GlobalMiddleware {
-    abstract handle(request: Request, next: RequestHandler): Promise<Response>
-}

package/Router/Websockets/Request.ts

@@ -1,3 +0,0 @@
-import { Request as BaseRequest } from '@Typetron/Router/Request'
-
-export class Request extends BaseRequest {}

package/Router/Websockets/WebsocketRoute.ts

@@ -1,61 +0,0 @@
-import { Container } from '../../Container'
-import { AnyFunction, Constructor, Type } from '../../Support'
-import { ControllerMetadata, MethodMetadata } from '../Metadata'
-import { Route } from '@Typetron/Router'
-
-export class WebsocketRoute extends Route {
-
-    async run(container: Container, requestParameters: Record<string, unknown>): Promise<object | string> {
-        const controller = await container.get(this.controller)
-
-        try {
-            const metadata: MethodMetadata | undefined = ControllerMetadata.get(this.controller).actions[this.controllerMethod]
-            const parameters = await this.resolveParameters(
-                requestParameters,
-                this.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).apply(controller, parameters)
-        } catch (unknownError) {
-            const error = unknownError as Error
-            error.stack = `Controller: ${controller.constructor.name}.${this.controllerMethod} \n at ` + error.stack
-            throw error
-        }
-    }
-
-    private async resolveParameters(
-        requestParameters: Record<string, unknown>,
-        parametersTypes: (Type<AnyFunction> | FunctionConstructor)[],
-        overrides: AnyFunction[],
-        container: Container
-    ) {
-        let parameterIndex = 0
-        // tslint:disable-next-line:no-any
-        const routeParameters: any[] = Object.values(requestParameters)
-        return parametersTypes.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, [routeParameters[parameterIndex++]])
-        })
-    }
-
-}
-