backendium 0.0.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "backendium",
+  "version": "0.0.0",
+  "description": "Express-based javascript backend framework with websocket support",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepack": "tsc"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "event-emitter-typescript": "^2.1.1",
+    "express": "^4.21.0",
+    "websocket-express": "^3.1.1",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "checkeasy": "^1.2.1"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/ws": "^8.5.12",
+    "typescript": "^5.5.3"
+  },
+  "files": ["src", "dist", "package.json", "readme.md", "tsconfig.json"]
+}

package/readme.md

@@ -0,0 +1,11 @@
+<h1 align="center">Backendium</h1>
+
+# Table of Contents
+> 1. [Installation](#installation)
+> 2. [Basics](#basics)
+> 3. [Registering handlers](#registering-handlers)
+# Installation
+```
+npm i backendium checkeasy
+```
+# Basics

package/src/handler.ts

@@ -0,0 +1,85 @@
+import BackendiumResponse from "./response.js";
+import Backendium from "./index.js";
+import {NextFunction, Request, RequestHandler, Response} from "express";
+import parseRequest, {BackendiumRequestOptionsType, BackendiumRequestType} from "./request.js";
+import {BackendiumRouter} from "./router";
+import {ValidationError} from "checkeasy";
+
+export type BackendiumHandlerReturnType = void | undefined | {code?: number, next?: boolean};
+export type BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType> = (request: BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>, response: BackendiumResponse, app: Backendium, next: NextFunction) => BackendiumHandlerReturnType | Promise<BackendiumHandlerReturnType>;
+
+export type RawHandlerType<DefaultAuthType> = (router: BackendiumRouter<DefaultAuthType>) => (app: Backendium) => RequestHandler;
+
+export function defaultAuthFailedHandler(request: Request, response: BackendiumResponse, app: Backendium) {
+    response.status(209);
+    response.end();
+}
+
+export function defaultErrorHandler(request: Request, response: BackendiumResponse, data: any, app: Backendium, error: any, message: string) {
+    response.status(500);
+    response.end(message ?? "Internal Server Error");
+    app.logger.requestError(request.url, data, error);
+}
+
+export function defaultValidationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, data: Buffer, error: ValidationError, message: string) {
+    response.status(400);
+    response.end(message ?? "Validation failed");
+}
+
+export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>(handler: BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>,
+    {auth, authChecker, authFailed, errorHandler, errorMessage, validationErrorHandler, validationErrorMessage, ...options}: BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthType, HeadersType>
+): RawHandlerType<GlobalAuthType> {
+    return (router: BackendiumRouter<GlobalAuthType>) => (app: Backendium) => (async (request: Request, response: Response, next: NextFunction) => {
+        let body: any;
+        try {
+            let req = await parseRequest(request, app, {...options, auth, authChecker, authFailed, errorHandler, validationErrorHandler, errorMessage, validationErrorMessage});
+            let res = new BackendiumResponse(response, app);
+            if (Array.isArray(req)) {
+                let [data, error] = req;
+                (validationErrorHandler ?? app.config.validationErrorHandler ?? defaultValidationErrorHandler)(request, res, app, data, error, validationErrorMessage ?? app.config.validationErrorMessage);
+                if (app.config.logging?.fullRequest) app.logger.requestFull(request.url, res.lastStatus, data, res.lastResponse);
+                else app.logger.request(request.url, res.lastStatus);
+                return;
+            }
+            body = req.body;
+            // @ts-ignore
+            let authData: AuthType = undefined;
+            if (authChecker) {
+                let ret = authChecker(request, res, app);
+                if (ret instanceof Promise) ret = await ret;
+                if (ret === null) {
+                    (authFailed ?? router.authFailed ?? app.authFailed ?? defaultAuthFailedHandler)(request, res, app);
+                    return;
+                }
+                authData = ret;
+            }
+            // @ts-ignore
+            let globalAuthData: GlobalAuthType = undefined;
+            if (!authChecker && auth && router.authChecker) {
+                let ret = router.authChecker(request, res, app);
+                if (ret instanceof Promise) ret = await ret;
+                if (ret === null) {
+                    (authFailed ?? router.authFailed ?? app.authFailed ?? defaultAuthFailedHandler)(request, res, app);
+                    return;
+                }
+                globalAuthData = ret;
+            }
+            let ret = handler({...req, auth: authData, globalAuth: globalAuthData}, res, app, next);
+            if (ret instanceof Promise) ret = await ret;
+            if (!ret) return;
+            let {code = 200, next: isNext = false} = ret;
+            response.status(code);
+            if (isNext) {
+                next();
+                return;
+            }
+            try {response.end();}
+            catch (error) {return;}
+            if (app.config.logging?.fullRequest) app.logger.requestFull(request.url, res.lastStatus, req.body, res.lastResponse);
+            else app.logger.request(request.url, res.lastStatus);
+        }
+        catch (error) {
+            (errorHandler ?? app.config.errorHandler ?? defaultErrorHandler)(request, new BackendiumResponse(response, app), body, app, error, errorMessage ?? app.config.errorMessage);
+        }
+    });
+}

package/src/index.ts

@@ -0,0 +1,109 @@
+import {Request, RequestHandler} from "express";
+import {Server} from "node:http";
+import {BackendiumRouter, MethodType} from "./router.js";
+import {EventEmitter, EventKey} from "event-emitter-typescript";
+import {WebSocketExpress, WSRequestHandler} from "websocket-express";
+import {BackendiumWebSocket} from "./ws.js";
+import Logger from "./logger";
+import BackendiumResponse from "./response";
+import {ValidationError} from "checkeasy";
+
+export type BackendiumConfigType = {
+    port: number,
+    host: string,
+    name: string,
+    version: string | number,
+    logging: {
+        path?: string,
+        fullRequest?: boolean,
+        fullWs?: boolean,
+        replaceConsoleLog?: boolean
+    }
+    autoLogFull: boolean,
+    autoLog: boolean,
+    autoLogWsFull: boolean,
+    autoLogWs: boolean,
+    errorMessage: string,
+    errorHandler(request: Request, response: BackendiumResponse, data: any, app: Backendium, error: any, message?: string): void,
+    validationErrorMessage: string,
+    validationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, data: Buffer, error: ValidationError, message?: string): void,
+    wsErrorMessage: string,
+    wsErrorHandler(data: Buffer, connection: BackendiumWebSocket<any>, app: Backendium, error: any): void
+}
+
+export type BackendiumEvents = {
+    starting: [],
+    start: [Server]
+};
+
+export default class Backendium<GlobalAuthType = any> extends BackendiumRouter<GlobalAuthType> {
+    public express = new WebSocketExpress;
+    protected eventEmitter = new EventEmitter<BackendiumEvents>;
+    public logger = new Logger(console.log.bind(console));
+    protected config_: Partial<BackendiumConfigType> = {};
+
+    constructor(config: Partial<BackendiumConfigType> = {}) {
+        super();
+        this.config = config;
+    }
+
+    get config() {return this.config_;}
+    set config(config) {
+        this.config_ = {...this.config_, ...config, logging: {...this.config_.logging, ...config.logging}};
+        if (this.config_.logging?.path) this.logger.path = this.config_.logging?.path;
+        if (this.config_.logging?.replaceConsoleLog ?? true) {
+            console.log = this.logger.message.bind(this.logger);
+            console.error = this.logger.error.bind(this.logger);
+        }
+    }
+    
+    protected addAnyRouteHandler(method: MethodType, handlers: Array<RequestHandler>) {
+        this.express[method]("*", ...handlers);
+    }
+
+    protected addRoutedHandler(method: MethodType, route: string, handlers: Array<RequestHandler>) {
+        this.express[method](route, ...handlers);
+    }
+
+    protected addWSHandler(route: string, handlers: Array<WSRequestHandler>) {
+        this.express.ws(route, ...handlers);
+    }
+
+    public on<E extends EventKey<BackendiumEvents>>(event: E, subscriber: (...args: BackendiumEvents[E]) => void): () => void {
+        return this.eventEmitter.on(event, (args) => subscriber(...args));
+    };
+
+    public once<E extends EventKey<BackendiumEvents>>(event: E, subscriber: (...args: BackendiumEvents[E]) => void): () => void {
+        return this.eventEmitter.once(event, (args) => subscriber(...args));
+    };
+
+    public off<E extends EventKey<BackendiumEvents>>(event: E, subscriber: (...args: BackendiumEvents[E]) => void): void {
+        this.eventEmitter.off(event, (args) => subscriber(...args));
+    };
+
+    public start(callback?: (server: Server) => void): Server {
+        this.handlers.forEach(([method, route, handlers]) => {
+            if (method == "ws") this.addWSHandler(route, handlers.map(handler => handler(this)));
+            else if (route) this.addRoutedHandler(method, route, handlers.map(handler => handler(this)));
+            else this.addAnyRouteHandler(method, handlers.map(handler => handler(this)));
+        });
+        this.eventEmitter.emit("starting", []);
+        // const server = this.express.createServer();
+        // server.listen(this.config.port ?? 8080, this.config.host ?? "localhost", () => {
+        //     if (callback) callback(server);
+        //     this.eventEmitter.emit("start", [server]);
+        // });
+        const server = this.express.listen(this.config_.port ?? 8080, this.config_.host ?? "localhost", () => {
+            this.logger.initMessage(this.config_.name ?? "app", this.config_.version ?? "0.0.0", this.config.port ?? 8080, this.config_.host ?? "localhost");
+            if (callback) callback(server);
+            this.eventEmitter.emit("start", [server]);
+        });
+        return server;
+    }
+
+    public async startAsync(): Promise<Server> {
+        return new Promise(resolve => {
+            this.start(resolve);
+        });
+    }
+}

package/src/logger.ts

@@ -0,0 +1,273 @@
+import chalk from "chalk";
+import * as fs from "node:fs";
+import * as util from "node:util";
+
+export function getDate() {
+    let date = new Date();
+    return `${date.getFullYear()}.${date.getMonth() + 1}.${date.getDate()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`;
+}
+
+export default class Logger {
+    protected logData = "";
+
+    constructor(public log: (...data: Array<string>) => void, protected path_?: string) {}
+    
+    get path(): string | undefined {return this.path_;}
+    set path(path: string) {
+        this.path_ = path;
+        if (this.path_) fs.writeFileSync(this.path_, this.logData);
+    }
+
+    clear() {
+        if (this.path_) fs.writeFileSync(this.path_, "");
+    }
+
+    logSeparately(consoleData: Array<any>, fileData: Array<string>) {
+        this.log(...consoleData);
+        this.logData += (this.logData.length ? '\n' : "") + fileData.join(' ');
+        if (this.path_) fs.writeFileSync(this.path_, this.logData);
+    }
+
+    getPrefix(tag: string) {
+        return `[${getDate()}] ${tag}:`;
+    }
+
+    Log(tag: string, func = chalk.white, ...data: Array<any>) {
+        let prefix = this.getPrefix(tag);
+        this.logSeparately([func(prefix), ...data.map((elem) => typeof elem !== "string" ? elem : func(elem))],
+            [prefix, ...data.map(elem => util.inspect(elem))]);
+    }
+
+    message(...data: Array<any>) {
+        return this.Log("info", chalk.white, ...data);
+    }
+
+    info(...data: Array<any>) {
+        return this.Log("info", chalk.white, ...data);
+    }
+
+    success(...data: Array<any>) {
+        return this.Log("success", chalk.green, ...data);
+    }
+
+    warning(...data: Array<any>) {
+        return this.Log("warn", chalk.yellow, ...data);
+    }
+
+    error(...data: Array<any>) {
+        return this.Log("error", chalk.redBright, ...data);
+    }
+
+    fatal(...data: Array<any>) {
+        return this.Log("fatal", chalk.red, ...data);
+    }
+
+    initMessage(name: string, version: string | number, port: number, host: string) {
+        this.logSeparately([chalk.greenBright(`--++== ${chalk.green(name)} ${chalk.cyan('v' + version)}; ${chalk.cyan(`${host}:${port}`)} ==++--`)],
+            [`--++== ${name} v${version}; port: ${port} ==++--`]);
+    }
+
+    protected formatData(data: any) {
+        return Buffer.isBuffer(data) ? `"${data.toString()}"` : typeof data === "string" ? `"${data}"` : data;
+    }
+
+    protected formatDataColors(data: any, color = chalk.cyan, defaultColor = chalk.green) {
+        return Buffer.isBuffer(data) ? defaultColor(`"${color(data.toString())}"`) : typeof data === "string" ? defaultColor(`"${color(data)}"`) : data;
+    }
+
+    requestFull(url: string, code: number, request: any, response: any) { // query, auth, headers
+        request = typeof request === "string" ? request.replaceAll("\n", "\\n") : request;
+        response = typeof response === "string" ? response.replaceAll("\n", "\\n") : response;
+        let toLog: Array<any> = [this.getPrefix("request"), `Handled request to`];
+        let toLogColours: Array<any> = [...toLog, chalk.cyan(url)];
+        // toLog[0] = '\n' + toLog[0];
+        toLog.push(url);
+        if (code !== undefined) {
+            toLog.push(". Code:", code);
+            toLogColours.push(". Code:", code);
+        }
+        if (request !== undefined) {
+            toLog.push(". Request:", this.formatData(request));
+            toLogColours.push(". Request:", this.formatDataColors(request));
+        }
+        if (response !== undefined) {
+            toLog.push(". Response:", this.formatData(response));
+            toLogColours.push(". Response:", this.formatDataColors(response));
+        }
+        this.logSeparately(toLogColours.map(elem => typeof elem === "string" ? chalk.green(elem) : elem), toLog);
+    }
+
+    request(url: string, code: number) {
+        let toLog: Array<any> = [this.getPrefix("request"), `Handled request to`];
+        let toLogColours: Array<any> = [...toLog, chalk.cyan(url)];
+        // toLog[0] = '\n' + toLog[0];
+        toLog.push(url);
+        if (code !== undefined) {
+            toLog.push(". Code:", code);
+            toLogColours.push(". Code:", code);
+        }
+        this.logSeparately(toLogColours.map(elem => typeof elem === "string" ? chalk.green(elem) : elem), toLog);
+    }
+
+    requestError(url: string, request: any, stackTrace: any) {
+        request = typeof request === "string" ? request.replaceAll("\n", "\\n") : request;
+        let toLog = [this.getPrefix("request"), `Error during handling request to`];
+        let toLogColours = [...toLog, chalk.cyan(url)];
+        // toLog[0] = '\n' + toLog[0];
+        toLog.push(url);
+        if (request !== undefined) {
+            toLog.push(". Request:", this.formatData(request));
+            toLogColours.push(`. Request:`, this.formatDataColors(request));
+        }
+        toLog.push(`\n${stackTrace}`);
+        toLogColours.push(`\n${stackTrace}`);
+        this.logSeparately(toLogColours.map(elem => typeof elem === "string" ? chalk.redBright(elem) : elem), toLog);
+    }
+
+    wsConnected(url: string) {
+        let prefix = this.getPrefix("wsConnected");
+        this.logSeparately([chalk.green(prefix), chalk.green("Websocket connected on url"), chalk.cyan(url)], [prefix, "Websocket connected on url", url]);
+    }
+
+    wsRejected(url: string) {
+        let prefix = this.getPrefix("wsRejected");
+        this.logSeparately([chalk.red(prefix), chalk.red("Websocket rejected on url"), chalk.cyan(url)], [prefix, "Websocket rejected on url", url]);
+    }
+
+    wsInitFull(url: string, data: any) {
+        let prefix = this.getPrefix("wsInit");
+        this.logSeparately(
+            [
+                chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.green("done"),
+                ...(data !== null && data !== undefined ? [chalk.green("Data:"), this.formatDataColors(data)] : [])
+            ],
+            [
+                prefix, "Websocket init on url", url, "done",
+                ...(data !== null && data !== undefined ? ["Data:", this.formatData(data)] : [])
+            ]
+        );
+    }
+
+    wsInitFailedFull(url: string, data: any) {
+        let prefix = this.getPrefix("wsInitFailed");
+        this.logSeparately(
+            [
+                chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.red("failed"),
+                ...(data !== null && data !== undefined ? [chalk.green("Data:"), this.formatDataColors(data)] : [])
+            ],
+            [
+                prefix, "Websocket init on url", url, "failed",
+                ...(data !== null && data !== undefined ? ["Data:", this.formatData(data)] : [])
+            ]
+        );
+    }
+
+    wsInit(url: string) {
+        let prefix = this.getPrefix("wsInit");
+        this.logSeparately([chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.red("done")],
+            [prefix, "Websocket init on url", url, "done"]);
+    }
+
+    wsInitFailed(url: string) {
+        let prefix = this.getPrefix("wsInitFailed");
+        this.logSeparately(
+            [chalk.green(prefix), chalk.green("Websocket init on url"), chalk.cyan(url), chalk.red("failed")],
+            [prefix, "Websocket init on url", url, "failed"]);
+    }
+
+    wsIncomingEventFull(url: string, event: string, data: any) {
+        let prefix = this.getPrefix("wsIncomingEvent");
+        this.logSeparately(
+            [
+                chalk.green(prefix), chalk.green("Client, connected on url"), chalk.cyan(url) + chalk.green(','), chalk.green("has emitted event"), chalk.green(`"${chalk.cyan(event)}"`),
+                ...(data !== null && data !== undefined ? [chalk.green("with data:"), this.formatDataColors(data)] : [])
+            ],
+            [
+                prefix, "Client, connected on url", url + ',', "has emitted event", `"${event}"`,
+                ...(data !== null && data !== undefined ? ["with data:", this.formatData(data)] : [])
+            ]
+        );
+    }
+
+    wsIncomingEvent(url: string, event: string) {
+        let prefix = this.getPrefix("wsIncomingEvent");
+        this.logSeparately([chalk.green(prefix), chalk.green("Client, connected on url"),
+                chalk.cyan(url) + chalk.green(','), chalk.green("has emitted event"), chalk.green(`${chalk.cyan(event)}`)],
+            [prefix, "Client, connected on url", url + ',', "has emitted event", `"${event}"`]);
+    }
+
+    wsOutgoingEventFull(url: string, event: string, data: any) {
+        let prefix = this.getPrefix("wsOutgoingEvent");
+        this.logSeparately(
+            [
+                chalk.green(prefix), chalk.green("Server has emitted event"), chalk.green(`"${chalk.cyan(event)}"`), chalk.green("to websocket connection on url"), chalk.cyan(url),
+                ...(data !== null && data !== undefined ? [chalk.green("with data:"), this.formatDataColors(data)] : [])
+            ], [
+                prefix, "Server has emitted event", `"${event}"`, "to websocket connection on url", url,
+                ...(data !== null && data !== undefined ? ["with data:", this.formatData(data)] : [])
+            ]
+        );
+    }
+
+    wsOutgoingEvent(url: string, event: string) {
+        let prefix = this.getPrefix("wsOutgoingEvent");
+        this.logSeparately([chalk.green(prefix), chalk.green("Server has emitted event"), chalk.green(`${chalk.cyan(event)}`), chalk.green("to websocket connection on url"), chalk.cyan(url)],
+            [prefix, "Server has emitted event", event, "to websocket connection on url", url]);
+    }
+
+    wsInputFull(url: string, data: any) {
+        let prefix = this.getPrefix("wsInput");
+        this.logSeparately([chalk.green(prefix), chalk.green("Client, connected on url"),
+                chalk.cyan(url) + chalk.green(','), chalk.green("has sent message"), this.formatDataColors(data)],
+            [prefix, "Client, connected on url", url + ',', "has sent message", this.formatData(data)]);
+    }
+
+    wsInput(url: string) {
+        let prefix = this.getPrefix("wsInput");
+        this.logSeparately([chalk.green(prefix), chalk.green("Client, connected on url"),
+                chalk.cyan(url) + chalk.green(','), chalk.green("has sent message")],
+            [prefix, "Client, connected on url", url + ',', "has sent message"]);
+    }
+
+    wsOutputFull(url: string, data: any) {
+        let prefix = this.getPrefix("wsOutput");
+        this.logSeparately([chalk.green(prefix), chalk.green("Server has sent message"), this.formatDataColors(data),
+            chalk.green("to websocket connection on url"),
+            chalk.cyan(url)], [prefix, "Server has sent message", this.formatData(data),
+            "to websocket connection on url", url]);
+    }
+
+    wsOutput(url: string) {
+        let prefix = this.getPrefix("wsOutput");
+        this.logSeparately([chalk.green(prefix), chalk.green("Server has sent message"),
+                chalk.green("to websocket connection on url"), chalk.cyan(url)],
+            [prefix, "Server has sent message", "to websocket connection on url", url]);
+    }
+
+    wsError(url: string, data: any, stackTrace: any) {
+        data = typeof data === "string" ? data.replaceAll("\n", "\\n") : data;
+        let toLog = [this.getPrefix("error"), `Error during handling websocket input to`];
+        let toLogColours = [...toLog, chalk.cyan(url)];
+        // toLog[0] = '\n' + toLog[0];
+        toLog.push(url);
+        if (data !== undefined) {
+            toLog.push(". Data:", this.formatData(data));
+            toLogColours.push(`. Data:`, this.formatDataColors(data));
+        }
+        toLog.push(`\n${stackTrace}`);
+        toLogColours.push(`\n${stackTrace}`);
+        this.logSeparately(toLogColours.map(elem => typeof elem === "string" ? chalk.redBright(elem) : elem), toLog);
+    }
+
+    wsClose(url: any) {
+        let prefix = this.getPrefix("wsClose");
+        this.logSeparately([chalk.green(prefix), chalk.green("Websocket connection on url"), chalk.cyan(url),
+            chalk.green("closed")], [prefix, "Websocket connection on url", url, "closed"]);
+    }
+
+    wsTerminate(url: any) {
+        let prefix = this.getPrefix("wsTerminate");
+        this.logSeparately([chalk.green(prefix), chalk.green("Websocket connection on url"), chalk.cyan(url),
+            chalk.red("terminated")], [prefix, "Websocket connection on url", url, "terminated"]);
+    }
+}

package/src/request.ts

@@ -0,0 +1,91 @@
+import {Request} from "express";
+import Backendium from "./index.js";
+import {ValidationError, Validator} from "checkeasy";
+import BackendiumResponse from "./response";
+
+export type ValidatorsType<BodyType, ParamsType, QueryType, HeadersType> = {
+    bodyValidator?: Validator<BodyType>,
+    paramsValidator?: Validator<ParamsType>,
+    queryValidator?: Validator<QueryType>,
+    headersValidator?: Validator<HeadersType>
+}
+
+export type AuthCheckerType<AuthType> = (request: Request, response: BackendiumResponse, app: Backendium) => AuthType | null | Promise<AuthType | null>;
+export type AuthFailedType = (request: Request, response: BackendiumResponse, app: Backendium) => void;
+
+export type BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthType, HeadersType> = ValidatorsType<BodyType, ParamsType, QueryType, HeadersType> & {
+    auth?: boolean,
+    authChecker?: AuthCheckerType<AuthType>,
+    authFailed?: AuthFailedType,
+    errorMessage?: string,
+    errorHandler?(request: Request, response: BackendiumResponse, data: any, app: Backendium, error: any): void,
+    validationErrorMessage?: string,
+    validationErrorHandler?(request: Request, response: BackendiumResponse, app: Backendium, data: Buffer, error: ValidationError, message?: string): void
+};
+
+export type BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, HeadersType, DefaultAuthType> = {
+    expressRequest: Request,
+    body: BodyType,
+    params: ParamsType,
+    query: QueryType,
+    headers: HeadersType,
+    bodyBuffer: Buffer,
+    options: BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthType, HeadersType>,
+    app: Backendium,
+    auth: AuthType,
+    globalAuth: DefaultAuthType
+}
+
+function parse<Type>(data: Buffer | object, validator?: Validator<Type>, root: string = ""): Type {
+    if (!validator) {
+        // @ts-ignore
+        return data;
+    }
+    try {
+        return validator(data, root);
+    }
+    catch (error0) {
+        if (Buffer.isBuffer(data)) {
+            try {
+                return validator(JSON.parse(data.toString()), root);
+            }
+            catch (error) {
+                if (error instanceof ValidationError) throw error;
+                throw error0;
+            }
+        }
+        throw error0;
+    }
+}
+
+async function getBody(request: Request): Promise<Buffer> {
+    if (request.body) return request.body;
+    return new Promise(resolve => {
+        let buffer = Buffer.alloc(0);
+        request.on("data", chunk => buffer = Buffer.concat([buffer, chunk]));
+        request.on("end", () => {
+            request.body = buffer;
+            resolve(buffer);
+        });
+    });
+}
+
+export default async function parseRequest<BodyType, ParamsType, QueryType, AuthType, HeadersType>(request: Request, app: Backendium,
+    {bodyValidator, paramsValidator, queryValidator, headersValidator, ...other}: BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthType, HeadersType>
+): Promise<Omit<Omit<BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, HeadersType, any>, "auth">, "globalAuth"> | [Buffer, ValidationError]> {
+    let bodyBuffer = await getBody(request);
+    try {
+        let body = parse(bodyBuffer, bodyValidator);
+        let params = parse(request.params, paramsValidator);
+        let query = parse(request.query, queryValidator);
+        let headers = parse(request.headers, headersValidator);
+        return {
+            expressRequest: request, body, params, query, headers, bodyBuffer, app,
+            options: {bodyValidator, paramsValidator, queryValidator, headersValidator, ...other}
+        };
+    }
+    catch (error) {
+        if (error instanceof ValidationError) return [bodyBuffer, error];
+        throw error;
+    }
+}

package/src/response.ts

@@ -0,0 +1,22 @@
+import {Response} from "express";
+import Backendium from "./index.js";
+
+export default class BackendiumResponse {
+    public lastStatus = 200;
+    public lastResponse: any;
+
+    constructor(public expressResponse: Response, public app: Backendium) {
+
+    }
+
+    status(status: number) {
+        this.lastStatus = status;
+        this.expressResponse.status(status);
+    }
+
+    end(data?: any, status?: number) {
+        if (status) this.status(status);
+        this.lastResponse = data;
+        this.expressResponse.end(typeof data === "string" || data instanceof Buffer || data instanceof ArrayBuffer ? data : JSON.stringify(data));
+    }
+}