backendium 0.0.15 → 0.0.17

package/dist/handler.d.ts

@@ -3,7 +3,7 @@ import Backendium from "./index.js";
 import { NextFunction, Request, RequestHandler } from "express";
 import { BackendiumRequestOptionsType, BackendiumRequestType } from "./request.js";
 import { BackendiumRouter } from "./router.js";
-import { ValidationError } from "checkeasy";
+import { ParsingError } from "parsium";
 export type BackendiumHandlerReturnType = void | undefined | {
     code?: number;
     next?: boolean;
@@ -12,5 +12,5 @@ export type BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, Hea
 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 declare function defaultValidationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, error: ParsingError, 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

@@ -1,65 +1,42 @@
-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";
+import { ParsingError } from "parsium";
 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");
+    response.end(message ?? "Internal Server Error");
     app.logger.requestError(request.url, data, error);
 }
-export function defaultValidationErrorHandler(request, response, app, data, error, message) {
+export function defaultValidationErrorHandler(request, response, app, error, message) {
     response.status(400);
-    response.end(message !== null && message !== void 0 ? message : "Validation failed: " + error.message);
+    response.end(message ?? "Validation failed: " + error.message);
 }
-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, _j, _k, _l;
+export default function backendiumHandler(handler, { auth, authChecker, authFailed, errorHandler, errorMessage, validationErrorHandler, validationErrorMessage, ...options }) {
+    return (router) => (app) => (async (request, response, next) => {
         let body;
         try {
-            let req = yield parseRequest(request, app, Object.assign(Object.assign({}, options), { auth, authChecker, authFailed, errorHandler, validationErrorHandler, errorMessage, validationErrorMessage }));
+            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;
-                ((_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);
+            if (req instanceof ParsingError) {
+                (validationErrorHandler ?? app.config.validationErrorHandler ?? defaultValidationErrorHandler)(request, res, app, req, validationErrorMessage ?? app.config.validationErrorMessage);
+                if (app.config.logging?.fullRequest)
+                    app.logger.requestFull(request.url, res.lastStatus, '"<invalid>"', 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;
+                    ret = await 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);
-                    if ((_e = app.config.logging) === null || _e === void 0 ? void 0 : _e.fullRequest)
+                    (authFailed ?? router.authFailed ?? app.authFailed ?? defaultAuthFailedHandler)(request, res, app);
+                    if (app.config.logging?.fullRequest)
                         app.logger.requestFull(request.url, res.lastStatus, req.body, res.lastResponse);
                     else
                         app.logger.request(request.url, res.lastStatus);
@@ -67,15 +44,14 @@ export default function backendiumHandler(handler, _a) {
                 }
                 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;
+                    ret = await ret;
                 if (ret === null) {
-                    ((_g = (_f = authFailed !== null && authFailed !== void 0 ? authFailed : router.authFailed) !== null && _f !== void 0 ? _f : app.authFailed) !== null && _g !== void 0 ? _g : defaultAuthFailedHandler)(request, res, app);
-                    if ((_h = app.config.logging) === null || _h === void 0 ? void 0 : _h.fullRequest)
+                    (authFailed ?? router.authFailed ?? app.authFailed ?? defaultAuthFailedHandler)(request, res, app);
+                    if (app.config.logging?.fullRequest)
                         app.logger.requestFull(request.url, res.lastStatus, req.body, res.lastResponse);
                     else
                         app.logger.request(request.url, res.lastStatus);
@@ -83,11 +59,11 @@ export default function backendiumHandler(handler, _a) {
                 }
                 globalAuthData = ret;
             }
-            let ret = handler(Object.assign(Object.assign({}, req), { auth: authData, globalAuth: globalAuthData }), res, app, next);
+            let ret = handler({ ...req, auth: authData, globalAuth: globalAuthData }, res, app, next);
             if (ret instanceof Promise)
-                ret = yield ret;
+                ret = await ret;
             if (!ret) {
-                if ((_j = app.config.logging) === null || _j === void 0 ? void 0 : _j.fullRequest)
+                if (app.config.logging?.fullRequest)
                     app.logger.requestFull(request.url, res.lastStatus, req.body, res.lastResponse);
                 else
                     app.logger.request(request.url, res.lastStatus);
@@ -103,13 +79,14 @@ export default function backendiumHandler(handler, _a) {
                 response.end();
             }
             catch (error) { }
-            if ((_k = app.config.logging) === null || _k === void 0 ? void 0 : _k.fullRequest)
+            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) {
-            ((_l = errorHandler !== null && errorHandler !== void 0 ? errorHandler : app.config.errorHandler) !== null && _l !== void 0 ? _l : defaultErrorHandler)(request, new BackendiumResponse(response, app), body, app, typeof error === "object" && error !== null && "stackTrace" in error ? error.stackTrace : error, errorMessage !== null && errorMessage !== void 0 ? errorMessage : app.config.errorMessage);
+            (errorHandler ?? app.config.errorHandler ?? defaultErrorHandler)(request, new BackendiumResponse(response, app), body, app, error, errorMessage ?? app.config.errorMessage);
         }
-    }));
+    });
 }
+// @TODO save some body chunks from parsium for logging

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { EventEmitter, EventKey } from "event-emitter-typescript";
 import { WebSocketExpress, WSRequestHandler } from "websocket-express";
 import { BackendiumWebSocket } from "./ws.js";
 import Logger from "./logger.js";
-import BackendiumResponse from "./response.js";
+import BackendiumResponse from "./response";
 import { ValidationError } from "checkeasy";
 import type { MethodType } from "./httpRouter.js";
 export type BackendiumConfigType = {
@@ -26,7 +26,7 @@ export type BackendiumConfigType = {
     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;
+    validationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, error: ValidationError, message?: string): void;
     wsErrorMessage: string;
     wsErrorHandler(data: Buffer, connection: BackendiumWebSocket<any>, app: Backendium, error: any): void;
 };

package/dist/index.js

@@ -1,32 +1,22 @@
-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.js";
 export default class Backendium extends BackendiumRouter {
+    express = new WebSocketExpress;
+    eventEmitter = new EventEmitter;
+    logger = new Logger(console.log.bind(console));
+    config_ = {};
     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) {
+        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);
         }
@@ -53,7 +43,6 @@ export default class Backendium extends BackendiumRouter {
     }
     ;
     start(callback) {
-        var _a, _b;
         this.handlers.forEach(([method, route, handlers]) => {
             if (method == "ws")
                 this.addWSHandler(route, handlers.map(handler => handler(this)));
@@ -68,20 +57,17 @@ export default class Backendium extends BackendiumRouter {
         //     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");
+        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;
     }
-    startAsync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise(resolve => {
-                this.start(resolve);
-            });
+    async startAsync() {
+        return new Promise(resolve => {
+            this.start(resolve);
         });
     }
 }

package/dist/logger.js

@@ -6,10 +6,12 @@ export function getDate() {
     return `${date.getFullYear()}.${date.getMonth() + 1}.${date.getDate()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`;
 }
 export default class Logger {
+    log;
+    path_;
+    logData = "";
     constructor(log, path_) {
         this.log = log;
         this.path_ = path_;
-        this.logData = "";
     }
     get path() { return this.path_; }
     set path(path) {

package/dist/request.d.ts

@@ -1,12 +1,12 @@
 import { Request } from "express";
 import Backendium from "./index.js";
-import { ValidationError, Validator } from "checkeasy";
-import BackendiumResponse from "./response";
+import { Parser, ParsingError } from "parsium";
+import BackendiumResponse from "./response.js";
 export type ValidatorsType<BodyType, ParamsType, QueryType, HeadersType> = {
-    bodyValidator?: Validator<BodyType>;
-    paramsValidator?: Validator<ParamsType>;
-    queryValidator?: Validator<QueryType>;
-    headersValidator?: Validator<HeadersType>;
+    bodyValidator?: Parser<BodyType>;
+    paramsValidator?: Parser<ParamsType>;
+    queryValidator?: Parser<QueryType>;
+    headersValidator?: Parser<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;
@@ -17,7 +17,7 @@ export type BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthTy
     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;
+    validationErrorHandler?(request: Request, response: BackendiumResponse, app: Backendium, error: ParsingError, message?: string): void;
 };
 export type BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, HeadersType, DefaultAuthType> = {
     expressRequest: Request;
@@ -25,10 +25,9 @@ export type BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, Hea
     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]>;
+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"> | ParsingError>;

package/dist/request.js

@@ -1,24 +1,4 @@
-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";
+import { any, ParsingError } from "parsium";
 function parse(data, validator, root = "") {
     if (!validator) {
         // @ts-ignore
@@ -33,7 +13,7 @@ function parse(data, validator, root = "") {
                 return validator(JSON.parse(data.toString()), root);
             }
             catch (error) {
-                if (error instanceof ValidationError)
+                if (error instanceof ParsingError)
                     throw error;
                 throw error0;
             }
@@ -41,38 +21,36 @@ function parse(data, validator, root = "") {
         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);
-            });
+async function getBody(request) {
+    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, "body");
-            let params = parse(request.params, paramsValidator, "params");
-            let query = parse(request.query, queryValidator, "query");
-            let headers = parse(request.headers, headersValidator, "headers");
-            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;
-        }
-    });
+export default async function parseRequest(request, app, { bodyValidator, paramsValidator, queryValidator, headersValidator, ...other }) {
+    // let bodyBuffer = await getBody(request);
+    try {
+        // let body = parse(bodyBuffer, bodyValidator, "body");
+        // let params = parse(request.params, paramsValidator, "params");
+        // let query = parse(request.query, queryValidator, "query");
+        // let headers = parse(request.headers, headersValidator, "headers");
+        let body = await (bodyValidator ?? any()).stream(request, "body");
+        let params = (paramsValidator ?? any())(request.params, "params");
+        let query = (queryValidator ?? any())(request.query, "query");
+        let headers = (headersValidator ?? any())(request.headers, "headers");
+        return {
+            expressRequest: request, body, params, query, headers, app,
+            options: { bodyValidator, paramsValidator, queryValidator, headersValidator, ...other }
+        };
+    }
+    catch (error) {
+        //if (error instanceof ParsingError) return error;
+        return error;
+    }
 }

package/dist/response.js

@@ -1,8 +1,11 @@
 export default class BackendiumResponse {
+    expressResponse;
+    app;
+    lastStatus = 200;
+    lastResponse;
     constructor(expressResponse, app) {
         this.expressResponse = expressResponse;
         this.app = app;
-        this.lastStatus = 200;
     }
     status(status) {
         this.lastStatus = status;

package/dist/router.js

@@ -2,12 +2,11 @@ import backendiumHandler from "./handler.js";
 import { WebSocketRouteConstructor } from "./ws.js";
 import { BackendiumHttpRouter } from "./httpRouter.js";
 export class BackendiumRouter extends BackendiumHttpRouter {
-    constructor() {
-        super(...arguments);
-        this._handlers = [];
-    }
+    _handlers = [];
+    authChecker;
+    authFailed;
     pushHandlers(method, path, options, handlers) {
-        this._handlers.push([method, path, handlers.map(handler => backendiumHandler(handler, options !== null && options !== void 0 ? options : { auth: false })(this))]);
+        this._handlers.push([method, path, handlers.map(handler => backendiumHandler(handler, options ?? { auth: false })(this))]);
     }
     get handlers() { return this._handlers; }
     ws(route) {
@@ -18,7 +17,7 @@ export class BackendiumRouter extends BackendiumHttpRouter {
         return constructor;
     }
     static addPrefix([method, route, handler], prefix) {
-        return [method, route || !(route === null || route === void 0 ? void 0 : route.startsWith("/")) ? prefix + (route !== null && route !== void 0 ? route : "") : prefix + (route !== null && route !== void 0 ? route : ""), handler];
+        return [method, route || !route?.startsWith("/") ? prefix + (route ?? "") : prefix + (route ?? ""), handler];
     }
     router(router, routePrefix = "") {
         this._handlers.push(...router._handlers.map((handler) => {
@@ -27,7 +26,7 @@ export class BackendiumRouter extends BackendiumHttpRouter {
         }));
     }
     setAuth(checker, failHandler) {
-        this.authChecker = checker !== null && checker !== void 0 ? checker : this.authChecker;
-        this.authFailed = failHandler !== null && failHandler !== void 0 ? failHandler : this.authFailed;
+        this.authChecker = checker ?? this.authChecker;
+        this.authFailed = failHandler ?? this.authFailed;
     }
 }

package/dist/ws.js

@@ -1,16 +1,18 @@
-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 { EventEmitter } from "event-emitter-typescript";
 import { ValidationError } from "checkeasy";
 export class BackendiumWebSocket {
+    socket;
+    wsConstructor;
+    app;
+    initData;
+    url;
+    eventEmitter = new EventEmitter;
+    wsEventEmitter = new EventEmitter;
+    events = new Set;
+    operations = new EventEmitter;
+    useEvents = false;
     static rawDataParse(data) {
+        // @ts-ignore
         return data instanceof Buffer ? data : data instanceof ArrayBuffer ? Buffer.from(data) : data.reduce((prev, cur) => Buffer.concat([prev, cur]), Buffer.alloc(0));
     }
     parseEventHead(head, message, socket, app) {
@@ -37,11 +39,10 @@ export class BackendiumWebSocket {
         this.operations.emit(operation, [payload, operationConfig, socket, app]);
     }
     parseEventMessage(message, socket, app, isBinary) {
-        var _a, _b, _c, _d;
         if (isBinary) {
             this.eventEmitter.emit("notEventMessage", [message, socket, app, isBinary]);
             this.wsConstructor.eventEmitter.emit("notEventMessage", [message, socket, app, isBinary]);
-            if ((_a = app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
+            if (app.config.logging?.fullWs)
                 app.logger.wsInputFull(this.url, message);
             else
                 app.logger.wsInput(this.url);
@@ -51,7 +52,7 @@ export class BackendiumWebSocket {
             let [head_, ...data] = message.toString().split("\n");
             let payload = Buffer.from(data.join("\n")), head = this.parseEventHead(head_, message, socket, app);
             if (!head) {
-                if ((_b = app.config.logging) === null || _b === void 0 ? void 0 : _b.fullWs)
+                if (app.config.logging?.fullWs)
                     app.logger.wsInputFull(this.url, message);
                 else
                     app.logger.wsInput(this.url);
@@ -59,7 +60,7 @@ export class BackendiumWebSocket {
             }
             if ("event" in head) {
                 this.emitIncomingEvent(head.event, payload, socket, app, head);
-                if ((_c = app.config.logging) === null || _c === void 0 ? void 0 : _c.fullWs)
+                if (app.config.logging?.fullWs)
                     app.logger.wsIncomingEventFull(this.url, head.event, payload.length ? payload : null);
                 else
                     app.logger.wsIncomingEvent(this.url, head.event);
@@ -70,7 +71,7 @@ export class BackendiumWebSocket {
         catch (error) {
             this.eventEmitter.emit("notEventMessage", [message, socket, app, isBinary]);
             this.wsConstructor.eventEmitter.emit("notEventMessage", [message, socket, app, isBinary]);
-            if ((_d = app.config.logging) === null || _d === void 0 ? void 0 : _d.fullWs)
+            if (app.config.logging?.fullWs)
                 app.logger.wsInputFull(this.url, message);
             else
                 app.logger.wsInput(this.url);
@@ -83,15 +84,9 @@ export class BackendiumWebSocket {
         this.app = app;
         this.initData = initData;
         this.url = url;
-        this.eventEmitter = new EventEmitter;
-        this.wsEventEmitter = new EventEmitter;
-        this.events = new Set;
-        this.operations = new EventEmitter;
-        this.useEvents = false;
         this.eventEmitter.emit("accept", [this, this.wsConstructor, app]);
         this.wsConstructor.eventEmitter.emit("accept", [this, this.wsConstructor, app]);
         socket.on("message", (data, isBinary) => {
-            var _a;
             let buffer = BackendiumWebSocket.rawDataParse(data);
             if (this.useEvents) {
                 this.eventEmitter.emit("messageBeforeEvents", [buffer, this, app, isBinary]);
@@ -101,7 +96,7 @@ export class BackendiumWebSocket {
             else {
                 this.eventEmitter.emit("notEventMessage", [buffer, this, app, isBinary]);
                 this.wsConstructor.eventEmitter.emit("notEventMessage", [buffer, this, app, isBinary]);
-                if ((_a = app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
+                if (app.config.logging?.fullWs)
                     app.logger.wsInputFull(url, data);
                 else
                     app.logger.wsInput(url);
@@ -152,7 +147,7 @@ export class BackendiumWebSocket {
                 return;
             }
             // @ts-ignore
-            callback(mainData, socket, app, validator !== null && validator !== void 0 ? validator : bufferValidator);
+            callback(mainData, socket, app, validator ?? bufferValidator);
         });
     }
     operation(event, subscriber) {
@@ -178,9 +173,8 @@ export class BackendiumWebSocket {
         this.socket.send(data);
     }
     send(data) {
-        var _a;
         this._send(data);
-        if ((_a = this.app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
+        if (this.app.config.logging?.fullWs)
             this.app.logger.wsOutputFull(this.url, data);
         else
             this.app.logger.wsOutput(this.url);
@@ -189,10 +183,9 @@ export class BackendiumWebSocket {
         return typeof data === "string" ? data : data instanceof Buffer ? data.toString() : data === undefined ? "undefined" : (typeof data === "number" && isNaN(data)) ? "NaN" : JSON.stringify(data);
     }
     emit(event, payload) {
-        var _a;
         BackendiumWebSocket.eventNameCheck(event);
         this._send(`$${event}\n${BackendiumWebSocket.AnyToString(payload)}`);
-        if ((_a = this.app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
+        if (this.app.config.logging?.fullWs)
             this.app.logger.wsOutgoingEventFull(this.url, event, payload);
         else
             this.app.logger.wsOutgoingEvent(this.url, event);
@@ -226,50 +219,47 @@ function parse(data, validator) {
     }
 }
 export class WebSocketRouteConstructor {
-    constructor() {
-        this.sockets = [];
-        this.eventEmitter = new EventEmitter;
-        this.eventHandlers = [];
-        this.operations = new EventEmitter;
-        this.initRequired = false;
-    }
+    sockets = [];
+    eventEmitter = new EventEmitter;
+    acceptRejectFn;
+    eventHandlers = [];
+    operations = new EventEmitter;
+    initRequired = false;
     _backendiumWebsocket(socket, app, initData, url) {
         let backendiumSocket = new BackendiumWebSocket(socket, this, app, initData, url);
         // @ts-ignore
         this.eventHandlers.forEach(([event, socket, validator]) => backendiumSocket.event(event, socket, validator));
     }
-    _handle(request, response, next, app) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.acceptRejectFn) {
-                let [flag, code, message] = yield this.acceptRejectFn(request, response, app);
-                if (!flag) {
-                    response.reject(code, message);
-                    app.logger.wsRejected(request.originalUrl);
-                    this.eventEmitter.emit("reject", [request, response, app, code, message]);
-                    return;
-                }
-            }
-            let socket = yield response.accept();
-            app.logger.wsConnected(request.originalUrl);
-            if (this.initRequired) {
-                socket.once("message", (data) => {
-                    this.eventEmitter.emit("init", [socket, BackendiumWebSocket.rawDataParse(data), app, request.originalUrl]);
-                });
+    async _handle(request, response, next, app) {
+        if (this.acceptRejectFn) {
+            let [flag, code, message] = await this.acceptRejectFn(request, response, app);
+            if (!flag) {
+                response.reject(code, message);
+                app.logger.wsRejected(request.originalUrl);
+                this.eventEmitter.emit("reject", [request, response, app, code, message]);
+                return;
             }
-            // @ts-ignore
-            else
-                this._backendiumWebsocket(socket, app, undefined, request.originalUrl);
-        });
+        }
+        let socket = await response.accept();
+        app.logger.wsConnected(request.originalUrl);
+        if (this.initRequired) {
+            socket.once("message", (data) => {
+                this.eventEmitter.emit("init", [socket, BackendiumWebSocket.rawDataParse(data), app, request.originalUrl]);
+            });
+        }
+        // @ts-ignore
+        else
+            this._backendiumWebsocket(socket, app, undefined, request.originalUrl);
     }
     acceptReject(callback) {
-        this.acceptRejectFn = (request, response, app) => __awaiter(this, void 0, void 0, function* () {
+        this.acceptRejectFn = async (request, response, app) => {
             let ans = callback(request, response, app), data;
             if (ans instanceof Promise)
-                data = yield ans;
+                data = await ans;
             else
                 data = ans;
             return typeof data === "boolean" ? [data, undefined, undefined] : [false, data[0], data[1]];
-        });
+        };
         return this;
     }
     event(event, callback, validator) {
@@ -303,12 +293,11 @@ export class WebSocketRouteConstructor {
     }
     requireInit(callback, validator) {
         this.initRequired = true;
-        this.on("init", (socket, data, app, url) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+        this.on("init", async (socket, data, app, url) => {
             let [mainData, parsed] = validator ? parse(data, validator) : [data, true];
             if (!parsed || !mainData) {
                 this.eventEmitter.emit("initParsingFailed", [data, socket, app, validator]);
-                if ((_a = app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
+                if (app.config.logging?.fullWs)
                     app.logger.wsInitFailedFull(url, data);
                 else
                     app.logger.wsInitFailed(url);
@@ -317,9 +306,9 @@ export class WebSocketRouteConstructor {
             // @ts-ignore
             let ret = callback(socket, mainData, app);
             if (ret instanceof Promise)
-                ret = yield ret;
+                ret = await ret;
             if (ret !== null) {
-                if ((_b = app.config.logging) === null || _b === void 0 ? void 0 : _b.fullWs)
+                if (app.config.logging?.fullWs)
                     app.logger.wsInitFull(url, mainData);
                 else
                     app.logger.wsInit(url);
@@ -327,12 +316,12 @@ export class WebSocketRouteConstructor {
             }
             else {
                 this.eventEmitter.emit("initFailed", [data, socket, app]);
-                if ((_c = app.config.logging) === null || _c === void 0 ? void 0 : _c.fullWs)
+                if (app.config.logging?.fullWs)
                     app.logger.wsInitFailedFull(url, mainData);
                 else
                     app.logger.wsInitFailed(url);
             }
-        }));
+        });
         return this;
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "backendium",
-  "version": "0.0.15",
-  "description": "Express-based javascript backend framework with websocket support and type-safe checkeasy validators",
+  "version": "0.0.17",
+  "description": "Express-based javascript backend framework with websocket support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -12,6 +12,7 @@
     "chalk": "^5.3.0",
     "event-emitter-typescript": "^2.1.1",
     "express": "^4.21.0",
+    "parsium": "^0.0.3",
     "websocket-express": "^3.1.1",
     "ws": "^8.18.0"
   },
@@ -25,4 +26,4 @@
   },
   "files": ["src", "dist", "package.json", "readme.md", "tsconfig.json"],
   "type": "module"
-}
+}

package/readme.md

@@ -149,7 +149,7 @@ router.setAuth((request, response) => {
 });
 
 router.post("/auth", (request, response) => {
-    console.log(request.globalAuth); // type of request.auth is string
+    console.log(request.globalAuth); // type of request.globalAuth is string
     response.end();
 }, {
     auth: true

package/src/handler.ts

@@ -3,7 +3,7 @@ import Backendium from "./index.js";
 import {NextFunction, Request, RequestHandler, Response} from "express";
 import parseRequest, {BackendiumRequestOptionsType, BackendiumRequestType} from "./request.js";
 import {BackendiumRouter} from "./router.js";
-import {ValidationError} from "checkeasy";
+import {ParsingError} from "parsium";
 
 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>;
@@ -21,7 +21,7 @@ export function defaultErrorHandler(request: Request, response: BackendiumRespon
     app.logger.requestError(request.url, data, error);
 }
 
-export function defaultValidationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, data: Buffer, error: ValidationError, message: string) {
+export function defaultValidationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, error: ParsingError, message: string) {
     response.status(400);
     response.end(message ?? "Validation failed: " + error.message);
 }
@@ -34,16 +34,14 @@ export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthT
         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);
+            if (req instanceof ParsingError) {
+                (validationErrorHandler ?? app.config.validationErrorHandler ?? defaultValidationErrorHandler)(request, res, app, req, validationErrorMessage ?? app.config.validationErrorMessage);
+                if (app.config.logging?.fullRequest) app.logger.requestFull(request.url, res.lastStatus, '"<invalid>"', res.lastResponse);
                 else app.logger.request(request.url, res.lastStatus);
                 return;
             }
             body = req.body;
-            // @ts-ignore
-            let authData: AuthType = undefined;
+            let authData: AuthType = undefined as unknown as AuthType;
             if (authChecker) {
                 let ret = authChecker(request, res, app);
                 if (ret instanceof Promise) ret = await ret;
@@ -55,8 +53,7 @@ export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthT
                 }
                 authData = ret;
             }
-            // @ts-ignore
-            let globalAuthData: GlobalAuthType = undefined;
+            let globalAuthData: GlobalAuthType = undefined as unknown as GlobalAuthType;
             if (!authChecker && auth && router.authChecker) {
                 let ret = router.authChecker(request, res, app);
                 if (ret instanceof Promise) ret = await ret;
@@ -87,7 +84,9 @@ export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthT
             else app.logger.request(request.url, res.lastStatus);
         }
         catch (error) {
-            (errorHandler ?? app.config.errorHandler ?? defaultErrorHandler)(request, new BackendiumResponse(response, app), body, app, typeof error === "object" && error !== null && "stackTrace" in error ? error.stackTrace : error, errorMessage ?? app.config.errorMessage);
+            (errorHandler ?? app.config.errorHandler ?? defaultErrorHandler)(request, new BackendiumResponse(response, app), body, app, error, errorMessage ?? app.config.errorMessage);
         }
     });
-}
+}
+
+// @TODO save some body chunks from parsium for logging

package/src/index.ts

@@ -5,7 +5,7 @@ import {EventEmitter, EventKey} from "event-emitter-typescript";
 import {WebSocketExpress, WSRequestHandler} from "websocket-express";
 import {BackendiumWebSocket} from "./ws.js";
 import Logger from "./logger.js";
-import BackendiumResponse from "./response.js";
+import BackendiumResponse from "./response";
 import {ValidationError} from "checkeasy";
 import type {MethodType} from "./httpRouter.js";
 
@@ -27,7 +27,7 @@ export type BackendiumConfigType = {
     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,
+    validationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, error: ValidationError, message?: string): void,
     wsErrorMessage: string,
     wsErrorHandler(data: Buffer, connection: BackendiumWebSocket<any>, app: Backendium, error: any): void
 }

package/src/request.ts

@@ -1,13 +1,13 @@
 import {Request} from "express";
 import Backendium from "./index.js";
-import {ValidationError, Validator} from "checkeasy";
-import BackendiumResponse from "./response";
+import {any, Parser, ParsingError} from "parsium";
+import BackendiumResponse from "./response.js";
 
 export type ValidatorsType<BodyType, ParamsType, QueryType, HeadersType> = {
-    bodyValidator?: Validator<BodyType>,
-    paramsValidator?: Validator<ParamsType>,
-    queryValidator?: Validator<QueryType>,
-    headersValidator?: Validator<HeadersType>
+    bodyValidator?: Parser<BodyType>,
+    paramsValidator?: Parser<ParamsType>,
+    queryValidator?: Parser<QueryType>,
+    headersValidator?: Parser<HeadersType>
 }
 
 export type AuthCheckerType<AuthType> = (request: Request, response: BackendiumResponse, app: Backendium) => AuthType | null | Promise<AuthType | null>;
@@ -20,7 +20,7 @@ export type BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthTy
     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
+    validationErrorHandler?(request: Request, response: BackendiumResponse, app: Backendium, error: ParsingError, message?: string): void
 };
 
 export type BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, HeadersType, DefaultAuthType> = {
@@ -29,14 +29,13 @@ export type BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, Hea
     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 {
+function parse<Type>(data: Buffer | object, validator?: Parser<Type>, root: string = ""): Type {
     if (!validator) {
         // @ts-ignore
         return data;
@@ -50,7 +49,7 @@ function parse<Type>(data: Buffer | object, validator?: Validator<Type>, root: s
                 return validator(JSON.parse(data.toString()), root);
             }
             catch (error) {
-                if (error instanceof ValidationError) throw error;
+                if (error instanceof ParsingError) throw error;
                 throw error0;
             }
         }
@@ -72,20 +71,24 @@ async function getBody(request: Request): Promise<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);
+): Promise<Omit<Omit<BackendiumRequestType<BodyType, ParamsType, QueryType, AuthType, HeadersType, any>, "auth">, "globalAuth"> | ParsingError> {
+    // let bodyBuffer = await getBody(request);
     try {
-        let body = parse(bodyBuffer, bodyValidator, "body");
-        let params = parse(request.params, paramsValidator, "params");
-        let query = parse(request.query, queryValidator, "query");
-        let headers = parse(request.headers, headersValidator, "headers");
+        // let body = parse(bodyBuffer, bodyValidator, "body");
+        // let params = parse(request.params, paramsValidator, "params");
+        // let query = parse(request.query, queryValidator, "query");
+        // let headers = parse(request.headers, headersValidator, "headers");
+        let body = await (bodyValidator ?? any<BodyType>()).stream(request, "body");
+        let params = (paramsValidator ?? any<ParamsType>())(request.params, "params");
+        let query = (queryValidator ?? any<QueryType>())(request.query, "query");
+        let headers = (headersValidator ?? any<HeadersType>())(request.headers, "headers");
         return {
-            expressRequest: request, body, params, query, headers, bodyBuffer, app,
+            expressRequest: request, body, params, query, headers, app,
             options: {bodyValidator, paramsValidator, queryValidator, headersValidator, ...other}
         };
     }
     catch (error) {
-        if (error instanceof ValidationError) return [bodyBuffer, error];
-        throw error;
+        //if (error instanceof ParsingError) return error;
+        return error as ParsingError;
     }
-}
+}

package/src/ws.ts

@@ -50,6 +50,7 @@ export class BackendiumWebSocket<InitDataType> {
     protected useEvents = false;
 
     public static rawDataParse(data: WebSocket.RawData): Buffer {
+        // @ts-ignore
         return data instanceof Buffer ? data : data instanceof ArrayBuffer ? Buffer.from(data) : data.reduce((prev, cur) => Buffer.concat([prev, cur]), Buffer.alloc(0));
     }
 

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */
-    "target": "es2016",
+    "target": "ES2022",
     "module": "ES2022",
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,