backendium 0.0.0

package/dist/response.js

@@ -0,0 +1,17 @@
+export default class BackendiumResponse {
+    constructor(expressResponse, app) {
+        this.expressResponse = expressResponse;
+        this.app = app;
+        this.lastStatus = 200;
+    }
+    status(status) {
+        this.lastStatus = status;
+        this.expressResponse.status(status);
+    }
+    end(data, status) {
+        if (status)
+            this.status(status);
+        this.lastResponse = data;
+        this.expressResponse.end(typeof data === "string" || data instanceof Buffer || data instanceof ArrayBuffer ? data : JSON.stringify(data));
+    }
+}

package/dist/router.d.ts

@@ -0,0 +1,60 @@
+import { BackendiumHandlerType, RawHandlerType } from "./handler.js";
+import { AuthCheckerType, AuthFailedType, BackendiumRequestOptionsType } from "./request.js";
+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> {
+    protected _handlers: Array<[MethodType, string | undefined, Array<ReturnType<RawHandlerType<GlobalAuthType>>>] | ["ws", string, Array<(app: Backendium) => WSRequestHandler>]>;
+    authChecker: AuthCheckerType<GlobalAuthType> | undefined;
+    authFailed: AuthFailedType | undefined;
+    constructor();
+    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>];
+    router<AuthType>(router: BackendiumRouter<AuthType>, routePrefix?: string): void;
+    setAuth(checker?: AuthCheckerType<GlobalAuthType>, failHandler?: AuthFailedType): void;
+}

package/dist/router.js

@@ -0,0 +1,138 @@
+import backendiumHandler from "./handler.js";
+import { WebSocketRouteConstructor } from "./ws.js";
+export class BackendiumRouter {
+    constructor() {
+        this._handlers = [];
+    }
+    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 !== null && options !== void 0 ? 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);
+    }
+    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);
+    }
+    ws(route) {
+        const constructor = new WebSocketRouteConstructor();
+        this._handlers.push(["ws", route, [(app) => (request, response, next) => {
+                    constructor._handle(request, response, next, app);
+                }]]);
+        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];
+    }
+    router(router, routePrefix = "") {
+        this._handlers.push(...router._handlers.map((handler) => {
+            // @ts-ignore
+            return BackendiumRouter.addPrefix(handler, routePrefix);
+        }));
+    }
+    setAuth(checker, failHandler) {
+        this.authChecker = checker !== null && checker !== void 0 ? checker : this.authChecker;
+        this.authFailed = failHandler !== null && failHandler !== void 0 ? failHandler : this.authFailed;
+    }
+}

package/dist/ws.d.ts

@@ -0,0 +1,101 @@
+import { NextFunction, Request } from "express";
+import { WSResponse } from "websocket-express";
+import Backendium from "./index.js";
+import { EventEmitter, EventKey } from "event-emitter-typescript";
+import { Validator } from "checkeasy";
+import * as WebSocket from "ws";
+import { ClientRequest, IncomingMessage } from "node:http";
+interface NextMessageOptions {
+    timeout?: number | undefined;
+}
+interface WebSocketMessage {
+    data: Buffer;
+    isBinary: boolean;
+}
+interface WebSocketExtension {
+    nextMessage(options?: NextMessageOptions): Promise<WebSocketMessage>;
+}
+export type WebSocketHeadEventType = {
+    event: string;
+};
+export type WebSocketHeadType = WebSocketHeadEventType | {
+    operation: string;
+    operationConfig: string;
+};
+export type BackendiumWebSocketEvents<InitDataType> = {
+    notEventMessage: [Buffer, BackendiumWebSocket<InitDataType>, Backendium, boolean];
+    unknownEvent: [Buffer, BackendiumWebSocket<InitDataType>, Backendium, WebSocketHeadEventType];
+    parsingFailed: [Buffer, BackendiumWebSocket<InitDataType>, Backendium, Validator<any> | undefined];
+    initParsingFailed: [Buffer, WebSocket & WebSocketExtension, Backendium, Validator<any> | undefined];
+    initFailed: [Buffer, WebSocket & WebSocketExtension, Backendium];
+    accept: [BackendiumWebSocket<InitDataType>, WebSocketRouteConstructor<InitDataType>, Backendium];
+    reject: [Request, WSResponse, Backendium, number | undefined, string | undefined];
+    message: [Buffer, BackendiumWebSocket<InitDataType>, Backendium, boolean];
+    messageBeforeEvents: [Buffer, BackendiumWebSocket<InitDataType>, Backendium, boolean];
+    close: [BackendiumWebSocket<InitDataType>, number, Buffer, Backendium];
+    error: [BackendiumWebSocket<InitDataType>, Error, Backendium];
+    init: [WebSocket & WebSocketExtension, Buffer, Backendium, string];
+    upgrade: [BackendiumWebSocket<InitDataType>, IncomingMessage, Backendium];
+    open: [BackendiumWebSocket<InitDataType>, Backendium];
+    ping: [BackendiumWebSocket<InitDataType>, Buffer, Backendium];
+    pong: [BackendiumWebSocket<InitDataType>, Buffer, Backendium];
+    unexpectedResponse: [BackendiumWebSocket<InitDataType>, ClientRequest, IncomingMessage, Backendium];
+};
+export declare class BackendiumWebSocket<InitDataType> {
+    socket: WebSocket & WebSocketExtension;
+    wsConstructor: WebSocketRouteConstructor<InitDataType>;
+    app: Backendium;
+    initData: InitDataType;
+    url: string;
+    protected eventEmitter: EventEmitter<BackendiumWebSocketEvents<InitDataType>>;
+    protected wsEventEmitter: EventEmitter<WebSocketEvents<InitDataType>>;
+    protected events: Set<string>;
+    protected operations: EventEmitter<WebSocketOperations<InitDataType>>;
+    protected useEvents: boolean;
+    static rawDataParse(data: WebSocket.RawData): Buffer;
+    protected parseEventHead(head: string, message: Buffer, socket: BackendiumWebSocket<InitDataType>, app: Backendium): WebSocketHeadType | undefined;
+    protected emitIncomingEvent(event: string, payload: Buffer, socket: BackendiumWebSocket<InitDataType>, app: Backendium, head: WebSocketHeadEventType): void;
+    protected emitIncomingOperation(operation: string, payload: Buffer, operationConfig: string, socket: BackendiumWebSocket<InitDataType>, app: Backendium): void;
+    protected parseEventMessage(message: Buffer, socket: BackendiumWebSocket<InitDataType>, app: Backendium, isBinary: boolean): void;
+    constructor(socket: WebSocket & WebSocketExtension, wsConstructor: WebSocketRouteConstructor<InitDataType>, app: Backendium, initData: InitDataType, url: string);
+    static eventNameCheck(str: string): void;
+    event<Type extends Buffer>(event: string, callback: (data: Type, socket: BackendiumWebSocket<InitDataType>, app: Backendium) => void): void;
+    event<Type>(event: string, callback: (data: Type, socket: BackendiumWebSocket<InitDataType>, app: Backendium, validator: Validator<Type>) => void, validator: Validator<Type>): void;
+    operation<E extends EventKey<WebSocketOperations<InitDataType>>>(event: E, subscriber: (...args: WebSocketOperations<InitDataType>[E]) => void): void;
+    on<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): () => void;
+    once<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): () => void;
+    off<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): void;
+    protected _send(data: any): void;
+    send(data: any): void;
+    protected static AnyToString(data: any): string;
+    emit(event: string, payload?: any): void;
+    emitOperation(event: string, operationConfig: any, payload: any): void;
+}
+export type WebSocketEvents<InitDataType> = {
+    [key: string]: [Buffer, BackendiumWebSocket<InitDataType>, Backendium];
+};
+export type WebSocketOperations<InitDataType> = {
+    [key: string]: [Buffer, string, BackendiumWebSocket<InitDataType>, Backendium];
+};
+export type AcceptResponseCallbackReturnType = boolean | [number | undefined] | [number | undefined, string | undefined];
+export declare class WebSocketRouteConstructor<InitDataType> {
+    protected sockets: Array<BackendiumWebSocket<InitDataType>>;
+    eventEmitter: EventEmitter<BackendiumWebSocketEvents<InitDataType>>;
+    protected acceptRejectFn: ((request: Request, response: WSResponse, app: Backendium) => Promise<[boolean, number | undefined, string | undefined]>) | undefined;
+    protected eventHandlers: Array<[string, (data: any, socket: BackendiumWebSocket<InitDataType>, app: Backendium, validator: Validator<any>) => void, Validator<any> | undefined]>;
+    protected operations: EventEmitter<WebSocketOperations<InitDataType>>;
+    protected initRequired: boolean;
+    protected _backendiumWebsocket(socket: WebSocket & WebSocketExtension, app: Backendium, initData: InitDataType, url: string): void;
+    _handle(request: Request, response: WSResponse, next: NextFunction, app: Backendium): Promise<void>;
+    acceptReject(callback: (request: Request, response: WSResponse, app: Backendium) => AcceptResponseCallbackReturnType | Promise<AcceptResponseCallbackReturnType>): WebSocketRouteConstructor<InitDataType>;
+    event<Type extends Buffer>(event: string, callback: (data: Type, socket: BackendiumWebSocket<InitDataType>, app: Backendium) => void): WebSocketRouteConstructor<InitDataType>;
+    event<Type>(event: string, callback: (data: Type, socket: BackendiumWebSocket<InitDataType>, app: Backendium, validator: Validator<Type>) => void, validator: Validator<Type>): WebSocketRouteConstructor<InitDataType>;
+    operation<E extends EventKey<WebSocketOperations<InitDataType>>>(event: E, subscriber: (...args: WebSocketOperations<InitDataType>[E]) => void): void;
+    on_<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): () => void;
+    once_<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): () => void;
+    on<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): WebSocketRouteConstructor<InitDataType>;
+    once<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): WebSocketRouteConstructor<InitDataType>;
+    off<E extends EventKey<BackendiumWebSocketEvents<InitDataType>>>(event: E, subscriber: (...args: BackendiumWebSocketEvents<InitDataType>[E]) => void): WebSocketRouteConstructor<InitDataType>;
+    requireInit<Type>(callback: (connection: WebSocket & WebSocketExtension, data: Type, app: Backendium) => null | InitDataType | Promise<null | InitDataType>, validator: Validator<Type>): void;
+}
+export {};

package/dist/ws.js

@@ -0,0 +1,338 @@
+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 {
+    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));
+    }
+    parseEventHead(head, message, socket, app) {
+        if (head.length < 1 || !head.startsWith("$")) {
+            this.eventEmitter.emit("notEventMessage", [message, socket, app, false]);
+            this.wsConstructor.eventEmitter.emit("notEventMessage", [message, socket, app, false]);
+            return;
+        }
+        let [, name, ...other] = head.split('$');
+        if (name.length)
+            return { event: name.trim() };
+        let [operation, ...operationConfig] = other;
+        return { operation: operation.trim(), operationConfig: operationConfig.join('$').trim() };
+    }
+    emitIncomingEvent(event, payload, socket, app, head) {
+        if (this.events.has(event))
+            this.wsEventEmitter.emit(event, [payload, socket, app]);
+        else {
+            this.eventEmitter.emit("unknownEvent", [payload, socket, app, head]);
+            this.wsConstructor.eventEmitter.emit("unknownEvent", [payload, socket, app, head]);
+        }
+    }
+    emitIncomingOperation(operation, payload, operationConfig, socket, app) {
+        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)
+                app.logger.wsInputFull(this.url, message);
+            else
+                app.logger.wsInput(this.url);
+            return;
+        }
+        try {
+            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)
+                    app.logger.wsInputFull(this.url, message);
+                else
+                    app.logger.wsInput(this.url);
+                return;
+            }
+            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)
+                    app.logger.wsIncomingEventFull(this.url, head.event, payload.length ? payload : null);
+                else
+                    app.logger.wsIncomingEvent(this.url, head.event);
+            }
+            else
+                this.emitIncomingOperation(head.operation, payload, head.operationConfig, socket, app);
+        }
+        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)
+                app.logger.wsInputFull(this.url, message);
+            else
+                app.logger.wsInput(this.url);
+            return;
+        }
+    }
+    constructor(socket, wsConstructor, app, initData, url) {
+        this.socket = socket;
+        this.wsConstructor = wsConstructor;
+        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]);
+                this.wsConstructor.eventEmitter.emit("messageBeforeEvents", [buffer, this, app, isBinary]);
+                this.parseEventMessage(buffer, this, app, isBinary);
+            }
+            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)
+                    app.logger.wsInputFull(url, data);
+                else
+                    app.logger.wsInput(url);
+            }
+            this.eventEmitter.emit("message", [buffer, this, app, isBinary]);
+            this.wsConstructor.eventEmitter.emit("message", [buffer, this, app, isBinary]);
+        });
+        socket.on("close", (code, reason) => {
+            this.eventEmitter.emit("close", [this, code, reason, app]);
+            this.wsConstructor.eventEmitter.emit("close", [this, code, reason, app]);
+            app.logger.wsClose(url);
+        });
+        socket.on("upgrade", (request) => {
+            this.eventEmitter.emit("upgrade", [this, request, app]);
+            this.wsConstructor.eventEmitter.emit("upgrade", [this, request, app]);
+        });
+        socket.on("open", () => {
+            this.eventEmitter.emit("open", [this, app]);
+            this.wsConstructor.eventEmitter.emit("open", [this, app]);
+        });
+        socket.on("ping", (buffer) => {
+            this.eventEmitter.emit("ping", [this, buffer, app]);
+            this.wsConstructor.eventEmitter.emit("ping", [this, buffer, app]);
+        });
+        socket.on("pong", (buffer) => {
+            this.eventEmitter.emit("pong", [this, buffer, app]);
+            this.wsConstructor.eventEmitter.emit("pong", [this, buffer, app]);
+        });
+        socket.on("unexpected-response", (clientResponse, request) => {
+            this.eventEmitter.emit("unexpectedResponse", [this, clientResponse, request, app]);
+            this.wsConstructor.eventEmitter.emit("unexpectedResponse", [this, clientResponse, request, app]);
+        });
+    }
+    static eventNameCheck(str) {
+        if (str.includes("$"))
+            throw new Error("event name cannot contain '$'");
+    }
+    event(event, callback, validator) {
+        this.useEvents = true;
+        event = event.trim();
+        BackendiumWebSocket.eventNameCheck(event);
+        this.events.add(event);
+        this.wsEventEmitter.on(event, ([data, socket, app]) => {
+            let [mainData, parsed] = validator ? parse(data, validator) : [data, true];
+            if (!parsed || !mainData) {
+                this.eventEmitter.emit("parsingFailed", [data, socket, app, validator]);
+                this.wsConstructor.eventEmitter.emit("parsingFailed", [data, socket, app, validator]);
+                return;
+            }
+            // @ts-ignore
+            callback(mainData, socket, app, validator !== null && validator !== void 0 ? validator : bufferValidator);
+        });
+    }
+    operation(event, subscriber) {
+        BackendiumWebSocket.eventNameCheck(event);
+        this.operations.on(event, (args) => subscriber(...args));
+    }
+    ;
+    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));
+    }
+    ;
+    _send(data) {
+        if (!(data instanceof Buffer) && typeof data === "object" || typeof data === "boolean")
+            data = JSON.stringify(data);
+        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)
+            this.app.logger.wsOutputFull(this.url, data);
+        else
+            this.app.logger.wsOutput(this.url);
+    }
+    static AnyToString(data) {
+        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)
+            this.app.logger.wsOutgoingEventFull(this.url, event, payload);
+        else
+            this.app.logger.wsOutgoingEvent(this.url, event);
+    }
+    emitOperation(event, operationConfig, payload) {
+        BackendiumWebSocket.eventNameCheck(event);
+        this._send(`$$${event}$${BackendiumWebSocket.AnyToString(operationConfig)}\n${BackendiumWebSocket.AnyToString(payload)}`);
+    }
+}
+const bufferValidator = (value, path) => {
+    if (value instanceof Buffer)
+        return value;
+    throw new ValidationError(`[${path}] is not buffer`);
+};
+function parse(data, validator) {
+    try {
+        return [validator(data, ""), true];
+    }
+    catch (error) {
+        try {
+            return [validator(data.toString(), ""), true];
+        }
+        catch (error) {
+            try {
+                return [validator(JSON.parse(data.toString()), ""), true];
+            }
+            catch (error) {
+                return [null, false];
+            }
+        }
+    }
+}
+export class WebSocketRouteConstructor {
+    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));
+    }
+    _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]);
+                });
+            }
+            // @ts-ignore
+            else
+                this._backendiumWebsocket(socket, app, undefined, request.originalUrl);
+        });
+    }
+    acceptReject(callback) {
+        this.acceptRejectFn = (request, response, app) => __awaiter(this, void 0, void 0, function* () {
+            let ans = callback(request, response, app), data;
+            if (ans instanceof Promise)
+                data = yield ans;
+            else
+                data = ans;
+            return typeof data === "boolean" ? [data, undefined, undefined] : [false, data[0], data[1]];
+        });
+        return this;
+    }
+    event(event, callback, validator) {
+        BackendiumWebSocket.eventNameCheck(event);
+        // @ts-ignore
+        this.sockets.forEach(socket => socket.event(event, callback, validator));
+        this.eventHandlers.push([event, callback, validator]);
+        return this;
+    }
+    operation(event, subscriber) {
+        BackendiumWebSocket.eventNameCheck(event);
+        this.operations.on(event, (args) => subscriber(...args));
+    }
+    on_(event, subscriber) {
+        return this.eventEmitter.on(event, (args) => subscriber(...args));
+    }
+    once_(event, subscriber) {
+        return this.eventEmitter.once(event, (args) => subscriber(...args));
+    }
+    on(event, subscriber) {
+        this.eventEmitter.on(event, (args) => subscriber(...args));
+        return this;
+    }
+    once(event, subscriber) {
+        this.eventEmitter.once(event, (args) => subscriber(...args));
+        return this;
+    }
+    off(event, subscriber) {
+        this.eventEmitter.off(event, (args) => subscriber(...args));
+        return this;
+    }
+    requireInit(callback, validator) {
+        this.initRequired = true;
+        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 ((_a = app.config.logging) === null || _a === void 0 ? void 0 : _a.fullWs)
+                    app.logger.wsInitFailedFull(url, data);
+                else
+                    app.logger.wsInitFailed(url);
+                return;
+            }
+            // @ts-ignore
+            let ret = callback(socket, mainData, app);
+            if (ret instanceof Promise)
+                ret = yield ret;
+            if (ret !== null) {
+                if ((_b = app.config.logging) === null || _b === void 0 ? void 0 : _b.fullWs)
+                    app.logger.wsInitFull(url, mainData);
+                else
+                    app.logger.wsInit(url);
+                this._backendiumWebsocket(socket, app, ret, url);
+            }
+            else {
+                this.eventEmitter.emit("initFailed", [data, socket, app]);
+                if ((_c = app.config.logging) === null || _c === void 0 ? void 0 : _c.fullWs)
+                    app.logger.wsInitFailedFull(url, mainData);
+                else
+                    app.logger.wsInitFailed(url);
+            }
+        }));
+    }
+}
+// @TODO error handling +termination logging