backendium 0.0.10 → 0.0.12

package/dist/request.js

@@ -1,3 +1,23 @@
+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) {
@@ -21,33 +41,38 @@ function parse(data, validator, root = "") {
         throw error0;
     }
 }
-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);
+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 async function parseRequest(request, app, { bodyValidator, paramsValidator, queryValidator, headersValidator, ...other }) {
-    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;
-    }
+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;
+        }
+    });
 }

package/dist/response.js

@@ -1,11 +1,8 @@
 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.d.ts

@@ -4,54 +4,13 @@ import { RequestHandler } from "express";
 import Backendium from "./index.js";
 import { WebSocketRouteConstructor } from "./ws.js";
 import { WSRequestHandler } from "websocket-express";
-export type MethodType = "use" | "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "checkout" | "connect" | "copy" | "lock" | "merge" | "mkactivity" | "mkcol" | "move" | "m-search" | "notify" | "propfind" | "proppatch" | "purge" | "report" | "search" | "subscribe" | "unsubscribe" | "trace" | "unlock" | "link" | "unlink" | "useHTTP";
-export type BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType> = Array<BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>> | [string, ...Array<BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>>] | [
-    ...Array<BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>>,
-    BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthType, HeadersType>
-] | [
-    string,
-    ...Array<BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>>,
-    BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthType, HeadersType>
-];
-export declare class BackendiumRouter<GlobalAuthType = undefined> {
+import { BackendiumHttpRouter, type MethodType } from "./httpRouter.js";
+export declare class BackendiumRouter<GlobalAuthType = undefined> extends BackendiumHttpRouter<GlobalAuthType> {
     protected _handlers: Array<[MethodType, string | undefined, Array<ReturnType<RawHandlerType<GlobalAuthType>>>] | ["ws", string, Array<(app: Backendium) => WSRequestHandler>]>;
     authChecker: AuthCheckerType<GlobalAuthType> | undefined;
     authFailed: AuthFailedType | undefined;
-    constructor();
+    protected pushHandlers<BodyType, ParamsType, QueryType, AuthType, HeadersType>(method: MethodType, path: string | undefined, options: BackendiumRequestOptionsType<BodyType, ParamsType, QueryType, AuthType, HeadersType> | undefined, handlers: Array<BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>>): void;
     get handlers(): ([MethodType, string | undefined, ((app: Backendium) => RequestHandler)[]] | ["ws", string, ((app: Backendium) => WSRequestHandler)[]])[];
-    protected parseArgs<BodyType, ParamsType, QueryType, AuthType, HeadersType>(args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): [string | undefined, Array<RawHandlerType<GlobalAuthType>>];
-    addHandler<BodyType, ParamsType, QueryType, AuthType, HeadersType>(method: MethodType, ...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    use<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    useHTTP<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    all<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    get<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    post<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    put<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    delete<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    patch<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    options<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    head<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    checkout<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    connect<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    copy<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    lock<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    merge<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    mkactivity<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    mkcol<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    move<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    "m-search"<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    notify<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    propfind<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    proppatch<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    purge<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    report<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    search<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    subscribe<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    unsubscribe<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    trace<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    unlock<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    link<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
-    unlink<BodyType = Buffer, ParamsType = {}, QueryType = {}, AuthType = GlobalAuthType, HeadersType = {}>(...args: BackendiumMethodArgsType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>): void;
     ws<InitDataType>(route: string): WebSocketRouteConstructor<InitDataType>;
     protected static addPrefix([method, route, handler]: [MethodType, string | undefined, Array<(app: Backendium) => RequestHandler>], prefix: string): [MethodType, string, Array<(app: Backendium) => RequestHandler>];
     protected static addPrefix([method, route, handler]: ["ws", string, Array<(app: Backendium) => WSRequestHandler>], prefix: string): ["ws", string, Array<(app: Backendium) => WSRequestHandler>];

package/dist/router.js

@@ -1,121 +1,15 @@
 import backendiumHandler from "./handler.js";
 import { WebSocketRouteConstructor } from "./ws.js";
-export class BackendiumRouter {
-    _handlers = [];
-    authChecker;
-    authFailed;
-    constructor() { }
-    get handlers() { return this._handlers; }
-    parseArgs(args) {
-        let route = undefined, options = undefined;
-        let handlers = args.map(elem => {
-            if (typeof elem === "string")
-                route = elem;
-            if (typeof elem === "function")
-                return elem;
-            // @ts-ignore
-            else
-                options = elem;
-        }).filter(elem => typeof elem === "function");
-        return [route, handlers.map(handler => backendiumHandler(handler, options ?? { auth: false }))];
-    }
-    addHandler(method, ...args) {
-        let [route, handlers] = this.parseArgs(args);
-        this._handlers.push([method, route, handlers.map(handler => handler(this))]);
-    }
-    use(...args) {
-        this.addHandler("use", ...args);
-    }
-    useHTTP(...args) {
-        this.addHandler("useHTTP", ...args);
-    }
-    all(...args) {
-        this.addHandler("all", ...args);
-    }
-    get(...args) {
-        this.addHandler("get", ...args);
-    }
-    post(...args) {
-        this.addHandler("post", ...args);
-    }
-    put(...args) {
-        this.addHandler("put", ...args);
-    }
-    delete(...args) {
-        this.addHandler("delete", ...args);
-    }
-    patch(...args) {
-        this.addHandler("patch", ...args);
-    }
-    options(...args) {
-        this.addHandler("options", ...args);
-    }
-    head(...args) {
-        this.addHandler("head", ...args);
-    }
-    checkout(...args) {
-        this.addHandler("checkout", ...args);
-    }
-    connect(...args) {
-        this.addHandler("connect", ...args);
-    }
-    copy(...args) {
-        this.addHandler("copy", ...args);
-    }
-    lock(...args) {
-        this.addHandler("lock", ...args);
+import { BackendiumHttpRouter } from "./httpRouter.js";
+export class BackendiumRouter extends BackendiumHttpRouter {
+    constructor() {
+        super(...arguments);
+        this._handlers = [];
     }
-    merge(...args) {
-        this.addHandler("merge", ...args);
-    }
-    mkactivity(...args) {
-        this.addHandler("mkactivity", ...args);
-    }
-    mkcol(...args) {
-        this.addHandler("mkcol", ...args);
-    }
-    move(...args) {
-        this.addHandler("move", ...args);
-    }
-    "m-search"(...args) {
-        this.addHandler("m-search", ...args);
-    }
-    notify(...args) {
-        this.addHandler("notify", ...args);
-    }
-    propfind(...args) {
-        this.addHandler("propfind", ...args);
-    }
-    proppatch(...args) {
-        this.addHandler("proppatch", ...args);
-    }
-    purge(...args) {
-        this.addHandler("purge", ...args);
-    }
-    report(...args) {
-        this.addHandler("report", ...args);
-    }
-    search(...args) {
-        this.addHandler("search", ...args);
-    }
-    subscribe(...args) {
-        this.addHandler("subscribe", ...args);
-    }
-    unsubscribe(...args) {
-        this.addHandler("unsubscribe", ...args);
-    }
-    trace(...args) {
-        this.addHandler("trace", ...args);
-    }
-    unlock(...args) {
-        this.addHandler("unlock", ...args);
-    }
-    link(...args) {
-        this.addHandler("link", ...args);
-    }
-    unlink(...args) {
-        this.addHandler("unlink", ...args);
+    pushHandlers(method, path, options, handlers) {
+        this._handlers.push([method, path, handlers.map(handler => backendiumHandler(handler, options !== null && options !== void 0 ? options : { auth: false })(this))]);
     }
+    get handlers() { return this._handlers; }
     ws(route) {
         let constructor = new WebSocketRouteConstructor;
         this._handlers.push(["ws", route, [(app) => (request, response, next) => {
@@ -124,7 +18,7 @@ export class BackendiumRouter {
         return constructor;
     }
     static addPrefix([method, route, handler], prefix) {
-        return [method, route || !route?.startsWith("/") ? prefix + (route ?? "") : prefix + (route ?? ""), handler];
+        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];
     }
     router(router, routePrefix = "") {
         this._handlers.push(...router._handlers.map((handler) => {
@@ -133,7 +27,7 @@ export class BackendiumRouter {
         }));
     }
     setAuth(checker, failHandler) {
-        this.authChecker = checker ?? this.authChecker;
-        this.authFailed = failHandler ?? this.authFailed;
+        this.authChecker = checker !== null && checker !== void 0 ? checker : this.authChecker;
+        this.authFailed = failHandler !== null && failHandler !== void 0 ? failHandler : this.authFailed;
     }
 }

package/dist/ws.js

@@ -1,16 +1,15 @@
+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) {
         return data instanceof Buffer ? data : data instanceof ArrayBuffer ? Buffer.from(data) : data.reduce((prev, cur) => Buffer.concat([prev, cur]), Buffer.alloc(0));
     }
@@ -38,10 +37,11 @@ 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 (app.config.logging?.fullWs)
+            if ((_a = app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
                 app.logger.wsInputFull(this.url, message);
             else
                 app.logger.wsInput(this.url);
@@ -51,7 +51,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 (app.config.logging?.fullWs)
+                if ((_b = app.config.logging) === null || _b === void 0 ? void 0 : _b.fullWs)
                     app.logger.wsInputFull(this.url, message);
                 else
                     app.logger.wsInput(this.url);
@@ -59,7 +59,7 @@ export class BackendiumWebSocket {
             }
             if ("event" in head) {
                 this.emitIncomingEvent(head.event, payload, socket, app, head);
-                if (app.config.logging?.fullWs)
+                if ((_c = app.config.logging) === null || _c === void 0 ? void 0 : _c.fullWs)
                     app.logger.wsIncomingEventFull(this.url, head.event, payload.length ? payload : null);
                 else
                     app.logger.wsIncomingEvent(this.url, head.event);
@@ -70,7 +70,7 @@ export class BackendiumWebSocket {
         catch (error) {
             this.eventEmitter.emit("notEventMessage", [message, socket, app, isBinary]);
             this.wsConstructor.eventEmitter.emit("notEventMessage", [message, socket, app, isBinary]);
-            if (app.config.logging?.fullWs)
+            if ((_d = app.config.logging) === null || _d === void 0 ? void 0 : _d.fullWs)
                 app.logger.wsInputFull(this.url, message);
             else
                 app.logger.wsInput(this.url);
@@ -83,9 +83,15 @@ 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]);
@@ -95,7 +101,7 @@ export class BackendiumWebSocket {
             else {
                 this.eventEmitter.emit("notEventMessage", [buffer, this, app, isBinary]);
                 this.wsConstructor.eventEmitter.emit("notEventMessage", [buffer, this, app, isBinary]);
-                if (app.config.logging?.fullWs)
+                if ((_a = app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
                     app.logger.wsInputFull(url, data);
                 else
                     app.logger.wsInput(url);
@@ -146,7 +152,7 @@ export class BackendiumWebSocket {
                 return;
             }
             // @ts-ignore
-            callback(mainData, socket, app, validator ?? bufferValidator);
+            callback(mainData, socket, app, validator !== null && validator !== void 0 ? validator : bufferValidator);
         });
     }
     operation(event, subscriber) {
@@ -172,8 +178,9 @@ export class BackendiumWebSocket {
         this.socket.send(data);
     }
     send(data) {
+        var _a;
         this._send(data);
-        if (this.app.config.logging?.fullWs)
+        if ((_a = this.app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
             this.app.logger.wsOutputFull(this.url, data);
         else
             this.app.logger.wsOutput(this.url);
@@ -182,9 +189,10 @@ 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 (this.app.config.logging?.fullWs)
+        if ((_a = this.app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
             this.app.logger.wsOutgoingEventFull(this.url, event, payload);
         else
             this.app.logger.wsOutgoingEvent(this.url, event);
@@ -218,47 +226,50 @@ function parse(data, validator) {
     }
 }
 export class WebSocketRouteConstructor {
-    sockets = [];
-    eventEmitter = new EventEmitter;
-    acceptRejectFn;
-    eventHandlers = [];
-    operations = new EventEmitter;
-    initRequired = false;
+    constructor() {
+        this.sockets = [];
+        this.eventEmitter = new EventEmitter;
+        this.eventHandlers = [];
+        this.operations = new EventEmitter;
+        this.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));
     }
-    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;
+    _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 = 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);
+            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]);
+                });
+            }
+            // @ts-ignore
+            else
+                this._backendiumWebsocket(socket, app, undefined, request.originalUrl);
+        });
     }
     acceptReject(callback) {
-        this.acceptRejectFn = async (request, response, app) => {
+        this.acceptRejectFn = (request, response, app) => __awaiter(this, void 0, void 0, function* () {
             let ans = callback(request, response, app), data;
             if (ans instanceof Promise)
-                data = await ans;
+                data = yield ans;
             else
                 data = ans;
             return typeof data === "boolean" ? [data, undefined, undefined] : [false, data[0], data[1]];
-        };
+        });
         return this;
     }
     event(event, callback, validator) {
@@ -292,11 +303,12 @@ export class WebSocketRouteConstructor {
     }
     requireInit(callback, validator) {
         this.initRequired = true;
-        this.on("init", async (socket, data, app, url) => {
+        this.on("init", (socket, data, app, url) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             let [mainData, parsed] = validator ? parse(data, validator) : [data, true];
             if (!parsed || !mainData) {
                 this.eventEmitter.emit("initParsingFailed", [data, socket, app, validator]);
-                if (app.config.logging?.fullWs)
+                if ((_a = app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
                     app.logger.wsInitFailedFull(url, data);
                 else
                     app.logger.wsInitFailed(url);
@@ -305,9 +317,9 @@ export class WebSocketRouteConstructor {
             // @ts-ignore
             let ret = callback(socket, mainData, app);
             if (ret instanceof Promise)
-                ret = await ret;
+                ret = yield ret;
             if (ret !== null) {
-                if (app.config.logging?.fullWs)
+                if ((_b = app.config.logging) === null || _b === void 0 ? void 0 : _b.fullWs)
                     app.logger.wsInitFull(url, mainData);
                 else
                     app.logger.wsInit(url);
@@ -315,12 +327,12 @@ export class WebSocketRouteConstructor {
             }
             else {
                 this.eventEmitter.emit("initFailed", [data, socket, app]);
-                if (app.config.logging?.fullWs)
+                if ((_c = app.config.logging) === null || _c === void 0 ? void 0 : _c.fullWs)
                     app.logger.wsInitFailedFull(url, mainData);
                 else
                     app.logger.wsInitFailed(url);
             }
-        });
+        }));
         return this;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backendium",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Express-based javascript backend framework with websocket support and type-safe checkeasy validators",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

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

package/src/handler.ts

@@ -23,7 +23,7 @@ export function defaultErrorHandler(request: Request, response: BackendiumRespon
 
 export function defaultValidationErrorHandler(request: Request, response: BackendiumResponse, app: Backendium, data: Buffer, error: ValidationError, message: string) {
     response.status(400);
-    response.end(message ?? "Validation failed"); // @TODO
+    response.end(message ?? "Validation failed: " + error.message);
 }
 
 export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>(handler: BackendiumHandlerType<BodyType, ParamsType, QueryType, AuthType, HeadersType, GlobalAuthType>,
@@ -49,6 +49,8 @@ export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthT
                 if (ret instanceof Promise) ret = await ret;
                 if (ret === null) {
                     (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);
                     return;
                 }
                 authData = ret;
@@ -60,13 +62,19 @@ export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthT
                 if (ret instanceof Promise) ret = await ret;
                 if (ret === null) {
                     (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);
                     return;
                 }
                 globalAuthData = ret;
             }
             let ret = handler({...req, auth: authData, globalAuth: globalAuthData}, res, app, next);
             if (ret instanceof Promise) ret = await ret;
-            if (!ret) return;
+            if (!ret) {
+                if (app.config.logging?.fullRequest) app.logger.requestFull(request.url, res.lastStatus, req.body, res.lastResponse);
+                else app.logger.request(request.url, res.lastStatus);
+                return;
+            }
             let {code = 200, next: isNext = false} = ret;
             response.status(code);
             if (isNext) {
@@ -74,7 +82,7 @@ export default function backendiumHandler<BodyType, ParamsType, QueryType, AuthT
                 return;
             }
             try {response.end();}
-            catch (error) {return;}
+            catch (error) {}
             if (app.config.logging?.fullRequest) app.logger.requestFull(request.url, res.lastStatus, req.body, res.lastResponse);
             else app.logger.request(request.url, res.lastStatus);
         }