@bool-ts/core 1.7.17 → 1.8.1

package/src/decorators/zodSchema.ts

@@ -1,5 +1,6 @@
 import * as Zod from "zod";
-import { controllerRouteZodSchemaKey } from "../keys";
+
+import { zodSchemaKey } from "../keys";
 
 export const ZodSchema = (schema: Zod.Schema) => {
     return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
@@ -7,13 +8,14 @@ export const ZodSchema = (schema: Zod.Schema) => {
             return;
         }
 
-        const zodSchemasMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName) || {};
+        const zodSchemasMetadata =
+            Reflect.getOwnMetadata(zodSchemaKey, target.constructor, methodName) || {};
 
         zodSchemasMetadata[`paramterIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             schema: schema
         };
 
-        Reflect.defineMetadata(controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(zodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
     };
 };

package/src/entities/{route.ts → httpRoute.ts}

@@ -2,19 +2,19 @@
 
 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 class Route {
+export class HttpRoute {
     public static rootPattern = ":([a-z0-9A-Z_-]{1,})";
     public static innerRootPattern = "([a-z0-9A-Z_-]{1,})";
 
     public readonly alias: string;
 
-    private _map = new Map<keyof THttpMethods, TRouteModel>();
+    private _map = new Map<keyof THttpMethods, THttpRouteModel>();
 
     constructor(alias: string) {
         this.alias = this._thinAlias(alias);
@@ -23,7 +23,10 @@ export class Route {
     public test(
         pathname: string,
         method: keyof THttpMethods
-    ): Readonly<{ parameters: Record<string, string>; model: TRouteModel }> | false | undefined {
+    ):
+        | Readonly<{ parameters: Record<string, string>; model: THttpRouteModel }>
+        | false
+        | undefined {
         try {
             const model = this._map.get(method);
             const aliasSplitted = this.alias.split("/");
@@ -39,7 +42,10 @@ export class Route {
             }
 
             const parameters: Record<string, string> = 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;
@@ -50,29 +56,32 @@ export class Route {
                 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) => {
-                        if (offset === 0) {
-                            pathnamePart.replace(
-                                new RegExp(Route.innerRootPattern, "g"),
-                                (innerMatch, innerKey, innerOffset) => {
-                                    if (innerOffset === 0) {
-                                        Object.assign(parameters, {
-                                            [key]: innerMatch
-                                        });
+                    aliasPart.replace(
+                        new RegExp(HttpRoute.rootPattern, "g"),
+                        (match, key, offset) => {
+                            if (offset === 0) {
+                                pathnamePart.replace(
+                                    new RegExp(HttpRoute.innerRootPattern, "g"),
+                                    (innerMatch, innerKey, innerOffset) => {
+                                        if (innerOffset === 0) {
+                                            Object.assign(parameters, {
+                                                [key]: innerMatch
+                                            });
+                                        }
+
+                                        return innerMatch;
                                     }
+                                );
+                            }
 
-                                    return innerMatch;
-                                }
-                            );
+                            return match;
                         }
-
-                        return match;
-                    });
+                    );
 
                     if (isFailed) {
                         return undefined;
@@ -118,23 +127,26 @@ export class Route {
                 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) => {
-                        if (!new RegExp(value, "g").test(pathnamePart)) {
-                            isFailed = true;
-                        } else {
-                            Object.assign(parameters, {
-                                [key]: pathnamePart
-                            });
+                    aliasPart.replace(
+                        new RegExp(HttpRoute.rootPattern, "g"),
+                        (subString, key, value) => {
+                            if (!new RegExp(value, "g").test(pathnamePart)) {
+                                isFailed = true;
+                            } else {
+                                Object.assign(parameters, {
+                                    [key]: pathnamePart
+                                });
+                            }
+                            return "";
                         }
-                        return "";
-                    });
+                    );
 
                     if (isFailed) {
                         return false;
@@ -156,10 +168,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public get(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("GET");
+    public get(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("GET");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             this._map.set("GET", handler);
         }
 
@@ -171,10 +183,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public post(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("POST");
+    public post(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("POST");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             this._map.set("POST", handler);
         }
 
@@ -186,10 +198,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public put(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("PUT");
+    public put(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("PUT");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             this._map.set("PUT", handler);
         }
 
@@ -201,10 +213,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public delete(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("DELETE");
+    public delete(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("DELETE");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             this._map.set("DELETE", handler);
         }
 
@@ -216,10 +228,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public connect(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("CONNECT");
+    public connect(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("CONNECT");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             return this._map.set("CONNECT", handler);
         }
 
@@ -231,10 +243,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public options(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("OPTIONS");
+    public options(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("OPTIONS");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             return this._map.set("OPTIONS", handler);
         }
 
@@ -246,10 +258,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public trace(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("TRACE");
+    public trace(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("TRACE");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             return this._map.set("TRACE", handler);
         }
 
@@ -261,10 +273,10 @@ export class Route {
      * @param handlers
      * @returns
      */
-    public patch(handler: TRouteModel) {
-        const currenTRouteModel = this._map.get("PATCH");
+    public patch(handler: THttpRouteModel) {
+        const currenTHttpRouteModel = this._map.get("PATCH");
 
-        if (!currenTRouteModel) {
+        if (!currenTHttpRouteModel) {
             return this._map.set("PATCH", handler);
         }
 
@@ -277,7 +289,9 @@ export class Route {
      * @returns
      */
     private _thinAlias(alias: string) {
-        return alias.replace(new RegExp("[/]{2,}", "g"), "/").replace(new RegExp("^[/]|[/]$", "g"), "");
+        return alias
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
     }
 
     /**
@@ -339,4 +353,4 @@ export class Route {
     }
 }
 
-export default Route;
+export default HttpRoute;

package/src/entities/{router.ts → httpRouter.ts}

@@ -1,11 +1,11 @@
 "use strict";
 
-import Route from "./route";
+import HttpRoute from "./httpRoute";
 
-export class Router {
+export class HttpRouter {
     public readonly alias: string;
 
-    private _routes: Map<string, Route> = new Map();
+    private _routes: Map<string, HttpRoute> = new Map();
 
     constructor(alias: string) {
         this.alias = this._thinAlias(alias);
@@ -14,7 +14,7 @@ export class Router {
     public route(alias: string) {
         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);
@@ -24,7 +24,9 @@ export class Router {
     }
 
     private _thinAlias(alias: string) {
-        return alias.replace(new RegExp("[/]{2,}", "g"), "/").replace(new RegExp("^[/]|[/]$", "g"), "");
+        return alias
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
     }
 
     get routes() {
@@ -32,4 +34,4 @@ export class Router {
     }
 }
 
-export default Router;
+export default HttpRouter;

package/src/entities/{routerGroup.ts → httpRouterGroup.ts}

@@ -1,10 +1,10 @@
 import type { THttpMethods } from "../http";
-import type { Router } from "./router";
+import type { HttpRouter } from "./httpRouter";
 
-export class RouterGroup {
-    private _routers: Map<string, Router> = new Map();
+export class HttpRouterGroup {
+    private _routers: Map<string, HttpRouter> = new Map();
 
-    public add(...routers: Array<Router>) {
+    public add(...routers: Array<HttpRouter>) {
         for (let i = 0; i < routers.length; i++) {
             if (this._routers.has(routers[i].alias)) {
                 continue;

package/src/entities/index.ts

@@ -1,5 +1,8 @@
-export type { TRouteModel } from "./route";
+export type { THttpRouteModel } from "./httpRoute";
 
-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/src/entities/webSocketRoute.ts

@@ -0,0 +1,35 @@
+import type { TWebSocketEventHandlerMetadata } from "../decorators";
+
+export class WebSocketRoute {
+    public readonly eventName: string;
+    public readonly metadata: TWebSocketEventHandlerMetadata;
+    private _context: Object | undefined = undefined;
+
+    constructor({
+        eventName,
+        metadata
+    }: {
+        eventName: string;
+        metadata: TWebSocketEventHandlerMetadata;
+    }) {
+        this.eventName = eventName;
+        this.metadata = metadata;
+    }
+
+    public bind(instance: Object): ThisType<WebSocketRoute> {
+        this._context = instance;
+
+        return this;
+    }
+
+    public execute(): Readonly<TWebSocketEventHandlerMetadata> {
+        return Object.freeze({
+            methodName: this.metadata.methodName,
+            descriptor:
+                !this._context || typeof this.metadata.descriptor.value !== "function"
+                    ? this.metadata.descriptor
+                    : this.metadata.descriptor.value.bind(this._context),
+            arguments: this.metadata.arguments
+        });
+    }
+}

package/src/entities/webSocketRouter.ts

@@ -0,0 +1,64 @@
+import type { TWebSocketEventHandlerMetadata } from "../decorators";
+import type { WebSocketRoute } from "./webSocketRoute";
+
+export class WebSocketRouter {
+    public readonly alias: string;
+    public readonly routes: Array<WebSocketRoute> = [];
+
+    constructor(public readonly rawAlias: string = "/") {
+        this.alias = WebSocketRouter.thinAlias(rawAlias);
+    }
+
+    /**
+     * Add websocket routes into router and start analysis
+     * @param routes
+     * @returns
+     */
+    public addRoutes(...routes: Array<WebSocketRoute>): ThisType<WebSocketRouter> {
+        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
+     */
+    public bind(instance: Object): ThisType<WebSocketRouter> {
+        for (const route of this.routes) {
+            route.bind(instance);
+        }
+
+        return this;
+    }
+
+    /**
+     * Generate map for websocket handler metadata
+     * @returns
+     */
+    public execute(): Map<string, TWebSocketEventHandlerMetadata> {
+        const map = new Map<string, TWebSocketEventHandlerMetadata>();
+
+        for (const route of this.routes) {
+            map.set(`${this.alias}:::${route.eventName}`, route.execute());
+        }
+
+        return map;
+    }
+
+    /**
+     * Handle alias for router, standardize
+     * @param alias
+     * @returns
+     */
+    public static thinAlias(alias: string): string {
+        return alias
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
+    }
+}

package/src/entities/webSocketRouterGroup.ts

@@ -0,0 +1,64 @@
+import type { TWebSocketEventHandlerMetadata } from "../decorators";
+import type { WebSocketRouter } from "./webSocketRouter";
+
+export class WebSocketRouterGroup {
+    public readonly prefix: string;
+    public readonly routers: Array<WebSocketRouter> = [];
+
+    constructor(public readonly rawPrefix: string = "/") {
+        this.prefix = WebSocketRouterGroup.thinPrefix(rawPrefix);
+    }
+
+    /**
+     *
+     * @param routers
+     * @returns
+     */
+    public addRouters(...routers: Array<WebSocketRouter>): ThisType<WebSocketRouterGroup> {
+        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
+     */
+    public execute(): Map<string, TWebSocketEventHandlerMetadata> {
+        const map = new Map<string, TWebSocketEventHandlerMetadata>();
+
+        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
+     */
+    public static thinPrefix(prefix: string): string {
+        return prefix
+            .replace(new RegExp("[/]{2,}", "g"), "/")
+            .replace(new RegExp("^[/]|[/]$", "g"), "");
+    }
+}