@bool-ts/core 1.7.17 → 1.8.0

package/dist/entities/{route.d.ts → httpRoute.d.ts}

@@ -1,10 +1,10 @@
 import type { THttpMethods } from "../http";
-export type TRouteModel<T = unknown> = Readonly<{
+export type THttpRouteModel<T = unknown> = Readonly<{
     class: new (...args: Array<any>) => T;
     funcName: string | symbol;
     func: (...args: Array<any>) => unknown;
 }>;
-export declare class Route {
+export declare class HttpRoute {
     static rootPattern: string;
     static innerRootPattern: string;
     readonly alias: string;
@@ -12,7 +12,7 @@ export declare class Route {
     constructor(alias: string);
     test(pathname: string, method: keyof THttpMethods): Readonly<{
         parameters: Record<string, string>;
-        model: TRouteModel;
+        model: THttpRouteModel;
     }> | false | undefined;
     /**
      *
@@ -23,31 +23,31 @@ export declare class Route {
      * @param handlers
      * @returns
      */
-    get(handler: TRouteModel): this;
+    get(handler: THttpRouteModel): this;
     /**
      *
      * @param handlers
      * @returns
      */
-    post(handler: TRouteModel): this;
+    post(handler: THttpRouteModel): this;
     /**
      *
      * @param handlers
      * @returns
      */
-    put(handler: TRouteModel): this;
+    put(handler: THttpRouteModel): this;
     /**
      *
      * @param handlers
      * @returns
      */
-    delete(handler: TRouteModel): this;
+    delete(handler: THttpRouteModel): this;
     /**
      *
      * @param handlers
      * @returns
      */
-    connect(handler: TRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    connect(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -57,7 +57,7 @@ export declare class Route {
      * @param handlers
      * @returns
      */
-    options(handler: TRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    options(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -67,7 +67,7 @@ export declare class Route {
      * @param handlers
      * @returns
      */
-    trace(handler: TRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    trace(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -77,7 +77,7 @@ export declare class Route {
      * @param handlers
      * @returns
      */
-    patch(handler: TRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    patch(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -99,4 +99,4 @@ export declare class Route {
      */
     get _filteredPath(): string;
 }
-export default Route;
+export default HttpRoute;

package/dist/entities/{route.js → httpRoute.js}

@@ -1,5 +1,5 @@
 "use strict";
-export class Route {
+export class HttpRoute {
     static rootPattern = ":([a-z0-9A-Z_-]{1,})";
     static innerRootPattern = "([a-z0-9A-Z_-]{1,})";
     alias;
@@ -20,7 +20,7 @@ export class Route {
                 return undefined;
             }
             const parameters = Object();
-            const matchingRegex = this.alias.replace(new RegExp(Route.rootPattern, "g"), Route.innerRootPattern);
+            const matchingRegex = this.alias.replace(new RegExp(HttpRoute.rootPattern, "g"), HttpRoute.innerRootPattern);
             if (!new RegExp(matchingRegex).test(this._thinAlias(pathname))) {
                 return undefined;
             }
@@ -28,15 +28,15 @@ export class Route {
                 const aliasPart = aliasSplitted[index];
                 const pathnamePart = currentPathNameSplitted[index];
                 // Check pathmane path match a dynamic syntax, if no match => start compare equal or not
-                if (!new RegExp(Route.rootPattern, "g").test(aliasPart)) {
+                if (!new RegExp(HttpRoute.rootPattern, "g").test(aliasPart)) {
                     if (aliasPart !== pathnamePart)
                         return undefined;
                 }
                 else {
                     let isFailed = false;
-                    aliasPart.replace(new RegExp(Route.rootPattern, "g"), (match, key, offset) => {
+                    aliasPart.replace(new RegExp(HttpRoute.rootPattern, "g"), (match, key, offset) => {
                         if (offset === 0) {
-                            pathnamePart.replace(new RegExp(Route.innerRootPattern, "g"), (innerMatch, innerKey, innerOffset) => {
+                            pathnamePart.replace(new RegExp(HttpRoute.innerRootPattern, "g"), (innerMatch, innerKey, innerOffset) => {
                                 if (innerOffset === 0) {
                                     Object.assign(parameters, {
                                         [key]: innerMatch
@@ -83,14 +83,14 @@ export class Route {
                 const aliasPart = aliasSplitted[index];
                 const pathnamePart = currentPathNameSplitted[index];
                 // Check pathmane path match a dynamic syntax, if no match => start compare equal or not
-                if (!new RegExp(Route.rootPattern, "g").test(aliasPart)) {
+                if (!new RegExp(HttpRoute.rootPattern, "g").test(aliasPart)) {
                     if (aliasPart !== pathnamePart) {
                         return false;
                     }
                 }
                 else {
                     let isFailed = false;
-                    aliasPart.replace(new RegExp(Route.rootPattern, "g"), (subString, key, value) => {
+                    aliasPart.replace(new RegExp(HttpRoute.rootPattern, "g"), (subString, key, value) => {
                         if (!new RegExp(value, "g").test(pathnamePart)) {
                             isFailed = true;
                         }
@@ -120,8 +120,8 @@ export class Route {
      * @returns
      */
     get(handler) {
-        const currenTRouteModel = this._map.get("GET");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("GET");
+        if (!currenTHttpRouteModel) {
             this._map.set("GET", handler);
         }
         return this;
@@ -132,8 +132,8 @@ export class Route {
      * @returns
      */
     post(handler) {
-        const currenTRouteModel = this._map.get("POST");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("POST");
+        if (!currenTHttpRouteModel) {
             this._map.set("POST", handler);
         }
         return this;
@@ -144,8 +144,8 @@ export class Route {
      * @returns
      */
     put(handler) {
-        const currenTRouteModel = this._map.get("PUT");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("PUT");
+        if (!currenTHttpRouteModel) {
             this._map.set("PUT", handler);
         }
         return this;
@@ -156,8 +156,8 @@ export class Route {
      * @returns
      */
     delete(handler) {
-        const currenTRouteModel = this._map.get("DELETE");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("DELETE");
+        if (!currenTHttpRouteModel) {
             this._map.set("DELETE", handler);
         }
         return this;
@@ -168,8 +168,8 @@ export class Route {
      * @returns
      */
     connect(handler) {
-        const currenTRouteModel = this._map.get("CONNECT");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("CONNECT");
+        if (!currenTHttpRouteModel) {
             return this._map.set("CONNECT", handler);
         }
         return this;
@@ -180,8 +180,8 @@ export class Route {
      * @returns
      */
     options(handler) {
-        const currenTRouteModel = this._map.get("OPTIONS");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("OPTIONS");
+        if (!currenTHttpRouteModel) {
             return this._map.set("OPTIONS", handler);
         }
         return this;
@@ -192,8 +192,8 @@ export class Route {
      * @returns
      */
     trace(handler) {
-        const currenTRouteModel = this._map.get("TRACE");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("TRACE");
+        if (!currenTHttpRouteModel) {
             return this._map.set("TRACE", handler);
         }
         return this;
@@ -204,8 +204,8 @@ export class Route {
      * @returns
      */
     patch(handler) {
-        const currenTRouteModel = this._map.get("PATCH");
-        if (!currenTRouteModel) {
+        const currenTHttpRouteModel = this._map.get("PATCH");
+        if (!currenTHttpRouteModel) {
             return this._map.set("PATCH", handler);
         }
         return this;
@@ -216,7 +216,9 @@ export class Route {
      * @returns
      */
     _thinAlias(alias) {
-        return alias.replace(new RegExp("[/]{2,}", "g"), "/").replace(new RegExp("^[/]|[/]$", "g"), "");
+        return alias
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
     }
     /**
      * Internal get fullpath after check regular expression
@@ -263,4 +265,4 @@ export class Route {
         return blockFiltered.join("/");
     }
 }
-export default Route;
+export default HttpRoute;

package/dist/entities/httpRouter.d.ts

@@ -0,0 +1,10 @@
+import HttpRoute from "./httpRoute";
+export declare class HttpRouter {
+    readonly alias: string;
+    private _routes;
+    constructor(alias: string);
+    route(alias: string): HttpRoute;
+    private _thinAlias;
+    get routes(): Map<string, HttpRoute>;
+}
+export default HttpRouter;

package/dist/entities/{router.js → httpRouter.js}

@@ -1,6 +1,6 @@
 "use strict";
-import Route from "./route";
-export class Router {
+import HttpRoute from "./httpRoute";
+export class HttpRouter {
     alias;
     _routes = new Map();
     constructor(alias) {
@@ -9,17 +9,19 @@ export class Router {
     route(alias) {
         const thinAlias = this._thinAlias(`${this.alias}/${alias}`);
         const route = this._routes.get(thinAlias);
-        const newRoute = !route ? new Route(`${this.alias}/${alias}`) : route;
+        const newRoute = !route ? new HttpRoute(`${this.alias}/${alias}`) : route;
         if (!route) {
             this._routes.set(thinAlias, newRoute);
         }
         return newRoute;
     }
     _thinAlias(alias) {
-        return alias.replace(new RegExp("[/]{2,}", "g"), "/").replace(new RegExp("^[/]|[/]$", "g"), "");
+        return alias
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
     }
     get routes() {
         return this._routes;
     }
 }
-export default Router;
+export default HttpRouter;

package/dist/entities/{routerGroup.d.ts → httpRouterGroup.d.ts}

@@ -1,10 +1,10 @@
 import type { THttpMethods } from "../http";
-import type { Router } from "./router";
-export declare class RouterGroup {
+import type { HttpRouter } from "./httpRouter";
+export declare class HttpRouterGroup {
     private _routers;
-    add(...routers: Array<Router>): this;
+    add(...routers: Array<HttpRouter>): this;
     find(pathame: string, method: keyof THttpMethods): Readonly<{
         parameters: Record<string, string>;
-        model: import("./route").TRouteModel;
+        model: import("./httpRoute").THttpRouteModel;
     }> | undefined;
 }

package/dist/entities/{routerGroup.js → httpRouterGroup.js}

@@ -1,4 +1,4 @@
-export class RouterGroup {
+export class HttpRouterGroup {
     _routers = new Map();
     add(...routers) {
         for (let i = 0; i < routers.length; i++) {

package/dist/entities/index.d.ts

@@ -1,4 +1,7 @@
-export type { TRouteModel } from "./route";
-export { Route } from "./route";
-export { Router } from "./router";
-export { RouterGroup } from "./routerGroup";
+export type { THttpRouteModel } from "./httpRoute";
+export { HttpRoute } from "./httpRoute";
+export { HttpRouter } from "./httpRouter";
+export { HttpRouterGroup } from "./httpRouterGroup";
+export { WebSocketRoute } from "./webSocketRoute";
+export { WebSocketRouter } from "./webSocketRouter";
+export { WebSocketRouterGroup } from "./webSocketRouterGroup";

package/dist/entities/index.js

@@ -1,3 +1,6 @@
-export { Route } from "./route";
-export { Router } from "./router";
-export { RouterGroup } from "./routerGroup";
+export { HttpRoute } from "./httpRoute";
+export { HttpRouter } from "./httpRouter";
+export { HttpRouterGroup } from "./httpRouterGroup";
+export { WebSocketRoute } from "./webSocketRoute";
+export { WebSocketRouter } from "./webSocketRouter";
+export { WebSocketRouterGroup } from "./webSocketRouterGroup";

package/dist/entities/webSocketRoute.d.ts

@@ -0,0 +1,10 @@
+import type { TWebSocketEventHandlerMetadata } from "../decorators";
+export declare class WebSocketRoute {
+    readonly eventName: string;
+    readonly metadata: TWebSocketEventHandlerMetadata;
+    constructor({ eventName, metadata }: {
+        eventName: string;
+        metadata: TWebSocketEventHandlerMetadata;
+    });
+    bind(instance: Object): ThisType<WebSocketRoute>;
+}

package/dist/entities/webSocketRoute.js

@@ -0,0 +1,15 @@
+export class WebSocketRoute {
+    eventName;
+    metadata;
+    constructor({ eventName, metadata }) {
+        this.eventName = eventName;
+        this.metadata = metadata;
+    }
+    bind(instance) {
+        if (typeof this.metadata.descriptor.value !== "function") {
+            return this;
+        }
+        this.metadata.descriptor.value = this.metadata.descriptor.value.bind(instance);
+        return this;
+    }
+}

package/dist/entities/webSocketRouter.d.ts

@@ -0,0 +1,31 @@
+import type { TWebSocketEventHandlerMetadata } from "../decorators";
+import type { WebSocketRoute } from "./webSocketRoute";
+export declare class WebSocketRouter {
+    readonly rawAlias: string;
+    readonly alias: string;
+    readonly routes: Array<WebSocketRoute>;
+    constructor(rawAlias?: string);
+    /**
+     * Add websocket routes into router and start analysis
+     * @param routes
+     * @returns
+     */
+    addRoutes(...routes: Array<WebSocketRoute>): ThisType<WebSocketRouter>;
+    /**
+     * Bind context for descriptor handler in the router
+     * @param instance
+     * @returns
+     */
+    bind(instance: Object): this;
+    /**
+     * Generate map for websocket handler metadata
+     * @returns
+     */
+    execute(): Map<string, TWebSocketEventHandlerMetadata>;
+    /**
+     * Handle alias for router, standardize
+     * @param alias
+     * @returns
+     */
+    static thinAlias(alias: string): string;
+}

package/dist/entities/webSocketRouter.js

@@ -0,0 +1,54 @@
+export class WebSocketRouter {
+    rawAlias;
+    alias;
+    routes = [];
+    constructor(rawAlias = "/") {
+        this.rawAlias = rawAlias;
+        this.alias = WebSocketRouter.thinAlias(rawAlias);
+    }
+    /**
+     * Add websocket routes into router and start analysis
+     * @param routes
+     * @returns
+     */
+    addRoutes(...routes) {
+        for (const route of routes) {
+            if (!this.routes.includes(route)) {
+                this.routes.push(route);
+            }
+        }
+        return this;
+    }
+    /**
+     * Bind context for descriptor handler in the router
+     * @param instance
+     * @returns
+     */
+    bind(instance) {
+        for (const route of this.routes) {
+            route.bind(instance);
+        }
+        return this;
+    }
+    /**
+     * Generate map for websocket handler metadata
+     * @returns
+     */
+    execute() {
+        const map = new Map();
+        for (const route of this.routes) {
+            map.set(`${this.alias}:::${route.eventName}`, route.metadata);
+        }
+        return map;
+    }
+    /**
+     * Handle alias for router, standardize
+     * @param alias
+     * @returns
+     */
+    static thinAlias(alias) {
+        return alias
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
+    }
+}

package/dist/entities/webSocketRouterGroup.d.ts

@@ -0,0 +1,25 @@
+import type { TWebSocketEventHandlerMetadata } from "../decorators";
+import type { WebSocketRouter } from "./webSocketRouter";
+export declare class WebSocketRouterGroup {
+    readonly rawPrefix: string;
+    readonly prefix: string;
+    readonly routers: Array<WebSocketRouter>;
+    constructor(rawPrefix?: string);
+    /**
+     *
+     * @param routers
+     * @returns
+     */
+    addRouters(...routers: Array<WebSocketRouter>): ThisType<WebSocketRouterGroup>;
+    /**
+     *
+     * @returns
+     */
+    execute(): Map<string, TWebSocketEventHandlerMetadata>;
+    /**
+     *
+     * @param prefix
+     * @returns
+     */
+    static thinPrefix(prefix: string): string;
+}

package/dist/entities/webSocketRouterGroup.js

@@ -0,0 +1,51 @@
+export class WebSocketRouterGroup {
+    rawPrefix;
+    prefix;
+    routers = [];
+    constructor(rawPrefix = "/") {
+        this.rawPrefix = rawPrefix;
+        this.prefix = WebSocketRouterGroup.thinPrefix(rawPrefix);
+    }
+    /**
+     *
+     * @param routers
+     * @returns
+     */
+    addRouters(...routers) {
+        for (let i = 0; i < routers.length; i++) {
+            if (!this.routers.includes(routers[i])) {
+                this.routers.push(routers[i]);
+            }
+        }
+        for (const router of routers) {
+            if (!this.routers.includes(router)) {
+                this.routers.push(router);
+            }
+        }
+        return this;
+    }
+    /**
+     *
+     * @returns
+     */
+    execute() {
+        const map = new Map();
+        for (const router of this.routers) {
+            const routerMap = router.execute();
+            for (const [routerKey, metadata] of routerMap.entries()) {
+                map.set(`/${WebSocketRouterGroup.thinPrefix(`${this.prefix}/${routerKey}`)}`, metadata);
+            }
+        }
+        return map;
+    }
+    /**
+     *
+     * @param prefix
+     * @returns
+     */
+    static thinPrefix(prefix) {
+        return prefix
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
+    }
+}

package/dist/hooks/factory.d.ts

@@ -1,11 +1,5 @@
-import type { IMiddleware } from "../interfaces";
-import type { IDispatcher } from "../interfaces/dispatcher";
-import "colors";
 import "reflect-metadata";
 import Qs from "qs";
-import * as Zod from "zod";
-import { RouterGroup } from "../entities";
-import { Injector } from "./injector";
 export type TGroupElementModel<TFuncName extends keyof TClass, TClass extends Object = Object, TFunc = TClass[TFuncName]> = Readonly<{
     class: TClass;
     func: TFunc;
@@ -34,38 +28,5 @@ export type TBoolFactoryOptions = Required<{
         headers: Array<string>;
     }>;
 }>;
-export declare const responseConverter: (response: Response) => Response;
-export declare const controllerCreator: (controllerConstructor: new (...args: any[]) => unknown, group: RouterGroup, injector: Injector, prefix?: string) => RouterGroup;
-export declare const argumentsResolution: (data: unknown, zodSchema: Zod.Schema, argumentIndex: number, funcName: string | symbol) => Promise<any>;
-export declare const moduleResolution: (module: new (...args: any[]) => unknown, options: TBoolFactoryOptions) => Promise<Readonly<{
-    prefix: string | undefined;
-    injector: Injector;
-    startMiddlewareGroup: Readonly<{
-        class: IMiddleware<any, any>;
-        func: (...args: any[]) => any;
-        funcName: "start";
-    }>[];
-    endMiddlewareGroup: Readonly<{
-        class: IMiddleware<any, any>;
-        func: (...args: any[]) => any;
-        funcName: "end";
-    }>[];
-    guardGroup: Readonly<{
-        class: new (...args: any[]) => any;
-        funcName: "enforce";
-        func: any;
-    }>[];
-    openDispatcherGroup: Readonly<{
-        class: IDispatcher<any, any>;
-        func: (...args: any[]) => any;
-        funcName: "open";
-    }>[];
-    closeDispatcherGroup: Readonly<{
-        class: IDispatcher<any, any>;
-        func: (...args: any[]) => any;
-        funcName: "close";
-    }>[];
-    routerGroup: RouterGroup;
-}> | undefined>;
 export declare const BoolFactory: (modules: Object | Array<Object>, options: TBoolFactoryOptions) => Promise<void>;
 export default BoolFactory;