@typetron/framework 0.5.5 → 0.5.7

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

@@ -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++]])
-        })
-    }
-
-}
-

package/Router/Websockets/index.ts

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

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

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

package/Storage/File.ts

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

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

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

package/Storage/Storage.ts

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

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

package/Storage/utils.ts

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