@typetron/framework 0.5.0 → 0.5.3

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

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