@typetron/framework 0.5.3 → 0.5.5

package/Router/Servers/uNetworking.ts

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

@@ -0,0 +1,82 @@
+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)
+        })
+
+        this.router.middleware.websocket?.forEach(middlewareClass => {
+            const middleware = container.get(middlewareClass)
+            stack = middleware.handle.bind(middleware, request, stack)
+        })
+
+        return await stack(request) as Response<T>
+    }
+}

package/Router/Websockets/Middleware.ts

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

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

package/Router/Websockets/WebsocketRoute.ts

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

package/Router/Websockets/index.ts

@@ -0,0 +1,57 @@
+import { WebSocket as uWebSocket } from 'uWebSockets.js'
+import { ActionResponse, WebsocketMessageStatus } from './types'
+import { Container } from '@Typetron/Container'
+
+export * from './Handler'
+export * from './types'
+
+export class WebSocket {
+
+    public connection: uWebSocket<any> & {container: Container}
+    id?: number | string
+
+    constructor(connection: uWebSocket<any>, public container: Container) {
+        this.connection = Object.assign(connection, {container})
+        this.reset(container)
+    }
+
+    subscribe(topic: string) {
+        this.connection.subscribe(topic)
+    }
+
+    unsubscribe(topic: string) {
+        this.connection.unsubscribe(topic)
+    }
+
+    reset(container?: Container) {
+        this.connection.container = container || this.connection.container.parent?.createChildContainer() || new Container()
+        this.connection.container.set(WebSocket, this)
+    }
+
+    // tslint:disable-next-line:no-any
+    publish(topic: string, action: string, body?: unknown) {
+        const sentResponse: ActionResponse<unknown> = {
+            action,
+            message: body,
+            status: WebsocketMessageStatus.OK,
+        }
+        this.connection.publish(topic, JSON.stringify(sentResponse), false, true)
+    }
+
+    // tslint:disable-next-line:no-any
+    publishAndSend(topic: string, action: string, body?: unknown) {
+        this.publish(topic, action, body)
+        this.send(action, body)
+    }
+
+    // tslint:disable-next-line:no-any
+    send(action: string, body?: unknown) {
+        const sentResponse: ActionResponse<unknown> = {
+            action,
+            message: body,
+            status: WebsocketMessageStatus.OK,
+        }
+        this.connection.send(JSON.stringify(sentResponse), false, true)
+    }
+}
+

package/Router/Websockets/types.ts

@@ -0,0 +1,23 @@
+export enum WebsocketMessageStatus {
+    OK = 'OK',
+    Error = 'Error',
+}
+
+export interface Action<T> {
+    action: string
+    message?: T
+}
+
+export interface ActionRequestMessage {
+    parameters?: (string | number)[]
+    // tslint:disable-next-line:no-any
+    body?: any
+}
+
+export type ActionRequest = Action<ActionRequestMessage>
+
+export interface ActionResponse<T> extends Action<T> {
+    status: WebsocketMessageStatus
+}
+
+export type ActionErrorResponse<T extends string = string> = ActionResponse<{message: T, stack: string}>

package/Router/index.ts

@@ -0,0 +1,6 @@
+export * from './Route'
+export * from './Router'
+export * from './Middleware'
+export * from './Decorators'
+export * from './RouteNotFoundError'
+export * from './BaseController'

package/Storage/File.ts

@@ -0,0 +1,30 @@
+import * as path from 'path'
+
+export class File {
+    // content?: string | Buffer
+    originalName?: string
+
+    saved = false
+
+    constructor(public name: string, public directory?: string) {
+    }
+
+    get extension() {
+        return this.guessExtension()
+    }
+
+    get path() {
+        return path.join(this.directory || '', this.name)
+    }
+
+    guessExtension() {
+        const fileParts = this.name.split('.')
+        if (fileParts.length >= 1) {
+            return fileParts.pop()
+        }
+    }
+
+    toString() {
+        return this.name
+    }
+}

package/Storage/Image.ts

@@ -0,0 +1,19 @@
+import { File } from './File'
+
+export class Image extends File {
+    // static fromBase64(base64: string): Image {
+    //     const matches = base64.match(/data:image\/([a-zA-Z]*);base64,([^\\"]*)/)
+    //     if (!matches) {
+    //         throw new InvalidImage()
+    //     }
+    //     if (matches.length !== 3) {
+    //         throw InvalidImage
+    //     }
+    //     const extension = matches[1]
+    //     const data = matches[2]
+    //
+    //     const image = new this('.' + extension)
+    //     image.content = Buffer.from(data, 'base64')
+    //     return image
+    // }
+}

package/Storage/InvalidImage.ts

@@ -0,0 +1,3 @@
+export class InvalidImage extends Error {
+    constructor() {super('The image has an invalid data format') }
+}

package/Storage/Storage.ts

@@ -0,0 +1,98 @@
+import * as fileSystemDeprecated from 'fs'
+import { File } from './File'
+import * as path from 'path'
+import * as fileSystem from 'node:fs/promises'
+
+export class Storage {
+    files(directory: string, recursively = false): File[] {
+        return fileSystemDeprecated
+            .readdirSync(directory) // TODO make this async
+            .reduce((files, name) => {
+                const filePath = path.join(directory, name)
+                const stats = fileSystemDeprecated.statSync(filePath)
+                if (stats.isFile()) {
+                    const file = new File(name)
+                    file.directory = directory
+                    files.push(file)
+                }
+
+                if (recursively && stats.isDirectory()) {
+                    files = files.concat(this.files(filePath))
+                }
+                return files
+            }, [] as File[])
+    }
+
+    async read(filePath: string): Promise<Buffer> {
+        return fileSystem.readFile(filePath)
+    }
+
+    async exists(filePath: string): Promise<boolean> {
+        try {
+            await fileSystem.access(filePath)
+            return true
+        } catch (error) {
+            return false
+        }
+    }
+
+    async save(file: File, directory: string = '', name?: string | number): Promise<File> {
+        const newPath = path.join(directory, file.name)
+        if (!file.name) {
+            file.name = String(name || this.generateRandomFileName() + '.' + file.extension)
+        }
+        if (directory && !(await this.exists(directory))) {
+            await this.makeDirectory(directory)
+        }
+        return new Promise(async (resolve, reject) => {
+            fileSystemDeprecated
+                .createReadStream(file.path)
+                .on('error', reject)
+                .pipe(fileSystemDeprecated.createWriteStream(newPath))
+                .on('finish', () => resolve(file))
+                .on('error', reject)
+        })
+    }
+
+    async put(filePath: string, content: string | Buffer, options?: any): Promise<File> {
+        const file = new File(path.basename(filePath))
+        file.directory = path.dirname(filePath)
+
+        if (file.directory && !(await this.exists(file.directory))) {
+            await this.makeDirectory(file.directory)
+        }
+
+        await fileSystem.writeFile(filePath, content, options)
+        return file
+    }
+
+    async makeDirectory(directory: string): Promise<void> {
+        await fileSystem.mkdir(directory, {recursive: true})
+    }
+
+    async deleteDirectory(directory: string): Promise<void> {
+        if (await this.exists(directory)) {
+            await fileSystem.rm(directory, {recursive: true})
+        }
+    }
+
+    async delete(filePath: string): Promise<void> {
+        if (!(await this.exists(filePath))) {
+            return
+        }
+
+        if ((await fileSystem.stat(filePath)).isDirectory()) {
+            throw new Error('Can not delete because this path leads to a directory and not a file.')
+        }
+
+        await fileSystem.unlink(filePath)
+    }
+
+    private generateRandomFileName(): string {
+        const stringDomain =
+            'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
+        return (
+            String.random(13, stringDomain) + '-' + new Date().getTime().toString()
+        )
+    }
+}

package/Storage/index.ts

@@ -0,0 +1,4 @@
+export * from './File'
+export * from './Storage'
+export * from './Image'
+export * from './utils'

package/Storage/utils.ts

@@ -0,0 +1,18 @@
+import { InvalidImage } from '@Typetron/Storage/InvalidImage'
+
+export function fromBase64(base64: string): {extension: string, content: Buffer} {
+    const matches = base64.match(/data:image\/([a-zA-Z]*);base64,([^\\"]*)/)
+    if (!matches) {
+        throw new InvalidImage()
+    }
+    if (matches.length !== 3) {
+        throw InvalidImage
+    }
+    const extension = matches[1]
+    const data = matches[2]
+
+    return {
+        content: Buffer.from(data, 'base64'),
+        extension: extension
+    }
+}