@typetron/framework 0.5.3 → 0.5.4

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

package/Router/Http/index.ts

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

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

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

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

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

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

package/Router/Router.ts

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

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

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