backendium 0.0.0

package/dist/handler.d.ts

@@ -0,0 +1,16 @@
+import BackendiumResponse from "./response.js";
+import Backendium from "./index.js";
+import { NextFunction, Request, RequestHandler } from "express";
+import { 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 declare function defaultAuthFailedHandler(request: Request, response: BackendiumResponse, app: Backendium): void;
+export declare function defaultErrorHandler(request: Request, response: BackendiumResponse, data: any, app: Backendium, error: any, message: string): void;
+export declare function defaultValidationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, data: Buffer, error: ValidationError, message: string): void;
+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>;

package/dist/handler.js

@@ -0,0 +1,104 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import BackendiumResponse from "./response.js";
+import parseRequest from "./request.js";
+export function defaultAuthFailedHandler(request, response, app) {
+    response.status(209);
+    response.end();
+}
+export function defaultErrorHandler(request, response, data, app, error, message) {
+    response.status(500);
+    response.end(message !== null && message !== void 0 ? message : "Internal Server Error");
+    app.logger.requestError(request.url, data, error);
+}
+export function defaultValidationErrorHandler(request, response, app, data, error, message) {
+    response.status(400);
+    response.end(message !== null && message !== void 0 ? message : "Validation failed");
+}
+export default function backendiumHandler(handler, _a) {
+    var { auth, authChecker, authFailed, errorHandler, errorMessage, validationErrorHandler, validationErrorMessage } = _a, options = __rest(_a, ["auth", "authChecker", "authFailed", "errorHandler", "errorMessage", "validationErrorHandler", "validationErrorMessage"]);
+    return (router) => (app) => ((request, response, next) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        let body;
+        try {
+            let req = yield parseRequest(request, app, Object.assign(Object.assign({}, options), { auth, authChecker, authFailed, errorHandler, validationErrorHandler, errorMessage, validationErrorMessage }));
+            let res = new BackendiumResponse(response, app);
+            if (Array.isArray(req)) {
+                let [data, error] = req;
+                ((_a = validationErrorHandler !== null && validationErrorHandler !== void 0 ? validationErrorHandler : app.config.validationErrorHandler) !== null && _a !== void 0 ? _a : defaultValidationErrorHandler)(request, res, app, data, error, validationErrorMessage !== null && validationErrorMessage !== void 0 ? validationErrorMessage : app.config.validationErrorMessage);
+                if ((_b = app.config.logging) === null || _b === void 0 ? void 0 : _b.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 = undefined;
+            if (authChecker) {
+                let ret = authChecker(request, res, app);
+                if (ret instanceof Promise)
+                    ret = yield ret;
+                if (ret === null) {
+                    ((_d = (_c = authFailed !== null && authFailed !== void 0 ? authFailed : router.authFailed) !== null && _c !== void 0 ? _c : app.authFailed) !== null && _d !== void 0 ? _d : defaultAuthFailedHandler)(request, res, app);
+                    return;
+                }
+                authData = ret;
+            }
+            // @ts-ignore
+            let globalAuthData = undefined;
+            if (!authChecker && auth && router.authChecker) {
+                let ret = router.authChecker(request, res, app);
+                if (ret instanceof Promise)
+                    ret = yield ret;
+                if (ret === null) {
+                    ((_f = (_e = authFailed !== null && authFailed !== void 0 ? authFailed : router.authFailed) !== null && _e !== void 0 ? _e : app.authFailed) !== null && _f !== void 0 ? _f : defaultAuthFailedHandler)(request, res, app);
+                    return;
+                }
+                globalAuthData = ret;
+            }
+            let ret = handler(Object.assign(Object.assign({}, req), { auth: authData, globalAuth: globalAuthData }), res, app, next);
+            if (ret instanceof Promise)
+                ret = yield 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 ((_g = app.config.logging) === null || _g === void 0 ? void 0 : _g.fullRequest)
+                app.logger.requestFull(request.url, res.lastStatus, req.body, res.lastResponse);
+            else
+                app.logger.request(request.url, res.lastStatus);
+        }
+        catch (error) {
+            ((_h = errorHandler !== null && errorHandler !== void 0 ? errorHandler : app.config.errorHandler) !== null && _h !== void 0 ? _h : defaultErrorHandler)(request, new BackendiumResponse(response, app), body, app, error, errorMessage !== null && errorMessage !== void 0 ? errorMessage : app.config.errorMessage);
+        }
+    }));
+}

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+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> {
+    express: WebSocketExpress;
+    protected eventEmitter: EventEmitter<BackendiumEvents>;
+    logger: Logger;
+    protected config_: Partial<BackendiumConfigType>;
+    constructor(config?: Partial<BackendiumConfigType>);
+    get config(): Partial<BackendiumConfigType>;
+    set config(config: Partial<BackendiumConfigType>);
+    protected addAnyRouteHandler(method: MethodType, handlers: Array<RequestHandler>): void;
+    protected addRoutedHandler(method: MethodType, route: string, handlers: Array<RequestHandler>): void;
+    protected addWSHandler(route: string, handlers: Array<WSRequestHandler>): void;
+    on<E extends EventKey<BackendiumEvents>>(event: E, subscriber: (...args: BackendiumEvents[E]) => void): () => void;
+    once<E extends EventKey<BackendiumEvents>>(event: E, subscriber: (...args: BackendiumEvents[E]) => void): () => void;
+    off<E extends EventKey<BackendiumEvents>>(event: E, subscriber: (...args: BackendiumEvents[E]) => void): void;
+    start(callback?: (server: Server) => void): Server;
+    startAsync(): Promise<Server>;
+}

package/dist/index.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BackendiumRouter } from "./router.js";
+import { EventEmitter } from "event-emitter-typescript";
+import { WebSocketExpress } from "websocket-express";
+import Logger from "./logger";
+export default class Backendium extends BackendiumRouter {
+    constructor(config = {}) {
+        super();
+        this.express = new WebSocketExpress;
+        this.eventEmitter = new EventEmitter;
+        this.logger = new Logger(console.log.bind(console));
+        this.config_ = {};
+        this.config = config;
+    }
+    get config() { return this.config_; }
+    set config(config) {
+        var _a, _b, _c, _d;
+        this.config_ = Object.assign(Object.assign(Object.assign({}, this.config_), config), { logging: Object.assign(Object.assign({}, this.config_.logging), config.logging) });
+        if ((_a = this.config_.logging) === null || _a === void 0 ? void 0 : _a.path)
+            this.logger.path = (_b = this.config_.logging) === null || _b === void 0 ? void 0 : _b.path;
+        if ((_d = (_c = this.config_.logging) === null || _c === void 0 ? void 0 : _c.replaceConsoleLog) !== null && _d !== void 0 ? _d : true) {
+            console.log = this.logger.message.bind(this.logger);
+            console.error = this.logger.error.bind(this.logger);
+        }
+    }
+    addAnyRouteHandler(method, handlers) {
+        this.express[method]("*", ...handlers);
+    }
+    addRoutedHandler(method, route, handlers) {
+        this.express[method](route, ...handlers);
+    }
+    addWSHandler(route, handlers) {
+        this.express.ws(route, ...handlers);
+    }
+    on(event, subscriber) {
+        return this.eventEmitter.on(event, (args) => subscriber(...args));
+    }
+    ;
+    once(event, subscriber) {
+        return this.eventEmitter.once(event, (args) => subscriber(...args));
+    }
+    ;
+    off(event, subscriber) {
+        this.eventEmitter.off(event, (args) => subscriber(...args));
+    }
+    ;
+    start(callback) {
+        var _a, _b;
+        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((_a = this.config_.port) !== null && _a !== void 0 ? _a : 8080, (_b = this.config_.host) !== null && _b !== void 0 ? _b : "localhost", () => {
+            var _a, _b, _c, _d;
+            this.logger.initMessage((_a = this.config_.name) !== null && _a !== void 0 ? _a : "app", (_b = this.config_.version) !== null && _b !== void 0 ? _b : "0.0.0", (_c = this.config.port) !== null && _c !== void 0 ? _c : 8080, (_d = this.config_.host) !== null && _d !== void 0 ? _d : "localhost");
+            if (callback)
+                callback(server);
+            this.eventEmitter.emit("start", [server]);
+        });
+        return server;
+    }
+    startAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(resolve => {
+                this.start(resolve);
+            });
+        });
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,42 @@
+export declare function getDate(): string;
+export default class Logger {
+    log: (...data: Array<string>) => void;
+    protected path_?: string | undefined;
+    protected logData: string;
+    constructor(log: (...data: Array<string>) => void, path_?: string | undefined);
+    get path(): string | undefined;
+    set path(path: string);
+    clear(): void;
+    logSeparately(consoleData: Array<any>, fileData: Array<string>): void;
+    getPrefix(tag: string): string;
+    Log(tag: string, func?: import("chalk").ChalkInstance, ...data: Array<any>): void;
+    message(...data: Array<any>): void;
+    info(...data: Array<any>): void;
+    success(...data: Array<any>): void;
+    warning(...data: Array<any>): void;
+    error(...data: Array<any>): void;
+    fatal(...data: Array<any>): void;
+    initMessage(name: string, version: string | number, port: number, host: string): void;
+    protected formatData(data: any): any;
+    protected formatDataColors(data: any, color?: import("chalk").ChalkInstance, defaultColor?: import("chalk").ChalkInstance): any;
+    requestFull(url: string, code: number, request: any, response: any): void;
+    request(url: string, code: number): void;
+    requestError(url: string, request: any, stackTrace: any): void;
+    wsConnected(url: string): void;
+    wsRejected(url: string): void;
+    wsInitFull(url: string, data: any): void;
+    wsInitFailedFull(url: string, data: any): void;
+    wsInit(url: string): void;
+    wsInitFailed(url: string): void;
+    wsIncomingEventFull(url: string, event: string, data: any): void;
+    wsIncomingEvent(url: string, event: string): void;
+    wsOutgoingEventFull(url: string, event: string, data: any): void;
+    wsOutgoingEvent(url: string, event: string): void;
+    wsInputFull(url: string, data: any): void;
+    wsInput(url: string): void;
+    wsOutputFull(url: string, data: any): void;
+    wsOutput(url: string): void;
+    wsError(url: string, data: any, stackTrace: any): void;
+    wsClose(url: any): void;
+    wsTerminate(url: any): void;
+}

package/dist/logger.js

@@ -0,0 +1,221 @@
+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 {
+    constructor(log, path_) {
+        this.log = log;
+        this.path_ = path_;
+        this.logData = "";
+    }
+    get path() { return this.path_; }
+    set path(path) {
+        this.path_ = path;
+        if (this.path_)
+            fs.writeFileSync(this.path_, this.logData);
+    }
+    clear() {
+        if (this.path_)
+            fs.writeFileSync(this.path_, "");
+    }
+    logSeparately(consoleData, fileData) {
+        this.log(...consoleData);
+        this.logData += (this.logData.length ? '\n' : "") + fileData.join(' ');
+        if (this.path_)
+            fs.writeFileSync(this.path_, this.logData);
+    }
+    getPrefix(tag) {
+        return `[${getDate()}] ${tag}:`;
+    }
+    Log(tag, func = chalk.white, ...data) {
+        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) {
+        return this.Log("info", chalk.white, ...data);
+    }
+    info(...data) {
+        return this.Log("info", chalk.white, ...data);
+    }
+    success(...data) {
+        return this.Log("success", chalk.green, ...data);
+    }
+    warning(...data) {
+        return this.Log("warn", chalk.yellow, ...data);
+    }
+    error(...data) {
+        return this.Log("error", chalk.redBright, ...data);
+    }
+    fatal(...data) {
+        return this.Log("fatal", chalk.red, ...data);
+    }
+    initMessage(name, version, port, host) {
+        this.logSeparately([chalk.greenBright(`--++== ${chalk.green(name)} ${chalk.cyan('v' + version)}; ${chalk.cyan(`${host}:${port}`)} ==++--`)], [`--++== ${name} v${version}; port: ${port} ==++--`]);
+    }
+    formatData(data) {
+        return Buffer.isBuffer(data) ? `"${data.toString()}"` : typeof data === "string" ? `"${data}"` : data;
+    }
+    formatDataColors(data, color = chalk.cyan, defaultColor = chalk.green) {
+        return Buffer.isBuffer(data) ? defaultColor(`"${color(data.toString())}"`) : typeof data === "string" ? defaultColor(`"${color(data)}"`) : data;
+    }
+    requestFull(url, code, request, response) {
+        request = typeof request === "string" ? request.replaceAll("\n", "\\n") : request;
+        response = typeof response === "string" ? response.replaceAll("\n", "\\n") : response;
+        let toLog = [this.getPrefix("request"), `Handled request to`];
+        let toLogColours = [...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, code) {
+        let toLog = [this.getPrefix("request"), `Handled request to`];
+        let toLogColours = [...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, request, stackTrace) {
+        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) {
+        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) {
+        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, data) {
+        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, data) {
+        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) {
+        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) {
+        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, event, data) {
+        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, event) {
+        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, event, data) {
+        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, event) {
+        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, data) {
+        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) {
+        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, data) {
+        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) {
+        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, data, stackTrace) {
+        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) {
+        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) {
+        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/dist/request.d.ts

@@ -0,0 +1,34 @@
+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;
+};
+export default 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]>;

package/dist/request.js

@@ -0,0 +1,78 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { ValidationError } from "checkeasy";
+function parse(data, validator, root = "") {
+    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;
+    }
+}
+function getBody(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 function parseRequest(request, app, _a) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var { bodyValidator, paramsValidator, queryValidator, headersValidator } = _a, other = __rest(_a, ["bodyValidator", "paramsValidator", "queryValidator", "headersValidator"]);
+        let bodyBuffer = yield 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: Object.assign({ bodyValidator, paramsValidator, queryValidator, headersValidator }, other)
+            };
+        }
+        catch (error) {
+            if (error instanceof ValidationError)
+                return [bodyBuffer, error];
+            throw error;
+        }
+    });
+}

package/dist/response.d.ts

@@ -0,0 +1,11 @@
+import { Response } from "express";
+import Backendium from "./index.js";
+export default class BackendiumResponse {
+    expressResponse: Response;
+    app: Backendium;
+    lastStatus: number;
+    lastResponse: any;
+    constructor(expressResponse: Response, app: Backendium);
+    status(status: number): void;
+    end(data?: any, status?: number): void;
+}