@bool-ts/core 2.1.2 → 2.2.0

package/src/entities/httpRoute.ts

@@ -1,5 +1,3 @@
-"use strict";
-
 import type { TArgumentsMetadataCollection } from "../decorators/arguments";
 import type { THttpMethods } from "../http";
 
@@ -10,16 +8,25 @@ export type THttpRouteModel<T = unknown> = Readonly<{
     argumentsMetadata: TArgumentsMetadataCollection;
 }>;
 
+const BASE_URL = "http://www.booljs.com";
+
 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, THttpRouteModel>();
+    #map = new Map<THttpMethods, THttpRouteModel>();
+    #urlPattern: URLPattern;
+
+    constructor({ alias }: { alias: string }) {
+        const thinAlias = this._thinAlias(alias);
 
-    constructor(alias: string) {
-        this.alias = this._thinAlias(alias);
+        this.alias = thinAlias;
+        this.#urlPattern = new URLPattern({
+            pathname: thinAlias,
+            baseURL: BASE_URL
+        });
     }
 
     /**
@@ -28,162 +35,62 @@ export class HttpRoute {
      * @param method
      * @returns
      */
-    public test(
-        pathname: string,
-        method: keyof THttpMethods
-    ):
-        | Readonly<{ parameters: Record<string, string>; model: THttpRouteModel }>
-        | false
-        | undefined {
+    public test({ pathname }: { pathname: string }): boolean {
         try {
-            const model = this._map.get(method);
-            const aliasSplitted = this.alias.split("/");
-            const currentPathNameSplitted = this._thinAlias(pathname).split("/");
-
-            if (!model) {
-                return undefined;
-            }
-
-            // Compare splitted length
-            if (aliasSplitted.length !== currentPathNameSplitted.length) {
-                return undefined;
-            }
-
-            const parameters: Record<string, string> = Object();
-            const matchingRegex = this.alias.replace(
-                new RegExp(HttpRoute.rootPattern, "g"),
-                HttpRoute.innerRootPattern
-            );
-
-            if (!new RegExp(matchingRegex).test(this._thinAlias(pathname))) {
-                return undefined;
-            }
-
-            for (let index = 0; index < aliasSplitted.length; index++) {
-                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(HttpRoute.rootPattern, "g").test(aliasPart)) {
-                    if (aliasPart !== pathnamePart) return undefined;
-                } else {
-                    let isFailed = false;
-
-                    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 match;
-                        }
-                    );
-
-                    if (isFailed) {
-                        return undefined;
-                    }
-                }
-
-                continue;
-            }
-
-            return Object.freeze({
-                parameters: parameters,
-                model: model
+            return this.#urlPattern.test({
+                pathname: this._thinAlias(pathname),
+                baseURL: BASE_URL
             });
-        } catch (err) {
-            console.error(err);
+        } catch (error) {
+            console.error(error);
+
             return false;
         }
     }
 
-    /**
-     *
-     * @param pathname
-     * @param method
-     * @returns
-     */
-    public isMatch(pathname: string, method: keyof THttpMethods) {
+    public exec({ pathname, method }: { pathname: string; method: THttpMethods }): Readonly<{
+        parameters: Record<string, string | undefined>;
+        model: THttpRouteModel;
+    }> | null {
         try {
-            const handlers = this._map.get(method);
+            const model = this.#map.get(method);
 
-            if (!handlers) {
-                return undefined;
+            if (!model) {
+                return null;
             }
 
-            const aliasSplitted = this.alias.split("/");
-            const currentPathNameSplitted = this._thinAlias(pathname).split("/");
+            const inferResult = this.#urlPattern.exec({
+                pathname: this._thinAlias(pathname),
+                baseURL: BASE_URL
+            });
 
-            // Compare splitted length
-            if (aliasSplitted.length !== currentPathNameSplitted.length) {
-                return false;
+            if (!inferResult) {
+                return null;
             }
 
-            const parameters = Object();
-
-            for (let index = 0; index < aliasSplitted.length; index++) {
-                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(HttpRoute.rootPattern, "g").test(aliasPart)) {
-                    if (aliasPart !== pathnamePart) {
-                        return false;
-                    }
-                } else {
-                    let isFailed = false;
-
-                    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 "";
-                        }
-                    );
-
-                    if (isFailed) {
-                        return false;
-                    }
-                }
+            const parameters = inferResult.pathname.groups;
 
-                continue;
-            }
+            return Object.freeze({
+                parameters: parameters,
+                model: model
+            });
+        } catch (error) {
+            console.error(error);
 
-            return true;
-        } catch (err) {
-            console.error(err);
-            return undefined;
+            return null;
         }
     }
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public get(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("GET");
+    public get({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("GET");
 
         if (!currenTHttpRouteModel) {
-            this._map.set("GET", handler);
+            this.#map.set("GET", model);
         }
 
         return this;
@@ -191,14 +98,14 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public post(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("POST");
+    public post({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("POST");
 
         if (!currenTHttpRouteModel) {
-            this._map.set("POST", handler);
+            this.#map.set("POST", model);
         }
 
         return this;
@@ -206,14 +113,14 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public put(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("PUT");
+    public put({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("PUT");
 
         if (!currenTHttpRouteModel) {
-            this._map.set("PUT", handler);
+            this.#map.set("PUT", model);
         }
 
         return this;
@@ -221,14 +128,14 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public delete(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("DELETE");
+    public delete({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("DELETE");
 
         if (!currenTHttpRouteModel) {
-            this._map.set("DELETE", handler);
+            this.#map.set("DELETE", model);
         }
 
         return this;
@@ -236,14 +143,14 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public connect(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("CONNECT");
+    public connect({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("CONNECT");
 
         if (!currenTHttpRouteModel) {
-            return this._map.set("CONNECT", handler);
+            return this.#map.set("CONNECT", model);
         }
 
         return this;
@@ -251,14 +158,14 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public options(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("OPTIONS");
+    public options({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("OPTIONS");
 
         if (!currenTHttpRouteModel) {
-            return this._map.set("OPTIONS", handler);
+            return this.#map.set("OPTIONS", model);
         }
 
         return this;
@@ -266,14 +173,14 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public trace(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("TRACE");
+    public trace({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("TRACE");
 
         if (!currenTHttpRouteModel) {
-            return this._map.set("TRACE", handler);
+            return this.#map.set("TRACE", model);
         }
 
         return this;
@@ -281,14 +188,14 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    public patch(handler: THttpRouteModel) {
-        const currenTHttpRouteModel = this._map.get("PATCH");
+    public patch({ model }: { model: THttpRouteModel }) {
+        const currenTHttpRouteModel = this.#map.get("PATCH");
 
         if (!currenTHttpRouteModel) {
-            return this._map.set("PATCH", handler);
+            return this.#map.set("PATCH", model);
         }
 
         return this;
@@ -296,7 +203,7 @@ export class HttpRoute {
 
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
     private _thinAlias(alias: string) {

package/src/entities/httpRouter.ts

@@ -1,5 +1,3 @@
-"use strict";
-
 import HttpRoute from "./httpRoute";
 
 export class HttpRouter {
@@ -7,7 +5,7 @@ export class HttpRouter {
 
     private _routes: Map<string, HttpRoute> = new Map();
 
-    constructor(alias: string) {
+    constructor({ alias }: { alias: string }) {
         this.alias = this._thinAlias(alias);
     }
 
@@ -19,7 +17,7 @@ export class HttpRouter {
     public route(alias: string) {
         const thinAlias = this._thinAlias(`${this.alias}/${alias}`);
         const route = this._routes.get(thinAlias);
-        const newRoute = !route ? new HttpRoute(`${this.alias}/${alias}`) : route;
+        const newRoute = !route ? new HttpRoute({ alias: `${this.alias}/${alias}` }) : route;
 
         if (!route) {
             this._routes.set(thinAlias, newRoute);

package/src/entities/httpRouterGroup.ts

@@ -1,4 +1,5 @@
 import type { THttpMethods } from "../http";
+import type { THttpRouteModel } from "./httpRoute";
 import type { HttpRouter } from "./httpRouter";
 
 export class HttpRouterGroup {
@@ -18,23 +19,32 @@ export class HttpRouterGroup {
 
     /**
      *
-     * @param pathame
+     * @param pathname
      * @param method
      * @returns
      */
-    public find(pathame: string, method: keyof THttpMethods) {
+    public find({ pathname, method }: { pathname: string; method: THttpMethods }): Readonly<{
+        parameters: Record<string, string | undefined>;
+        model: THttpRouteModel;
+    }> | null {
         for (const router of this._routers.values()) {
             for (const route of router.routes.values()) {
-                const result = route.test(pathame, method);
+                const testResult = route.test({ pathname });
 
-                if (!result) {
+                if (!testResult) {
                     continue;
                 }
 
-                return result;
+                const execResult = route.exec({ pathname, method });
+
+                if (!execResult) {
+                    continue;
+                }
+
+                return execResult;
             }
         }
 
-        return undefined;
+        return null;
     }
 }

package/src/http/clientError.ts

@@ -30,12 +30,15 @@ export const httpClientErrors = Object.freeze({
     451: "UNAVAILABLE_FOR_LEGAL_REASONS"
 });
 
-export class HttpClientError<T extends keyof typeof httpClientErrors = keyof typeof httpClientErrors, K = any> extends Error {
+export class HttpClientError<
+    T extends keyof typeof httpClientErrors = keyof typeof httpClientErrors,
+    K = unknown
+> extends Error {
     public readonly httpCode: T;
     public readonly message: (typeof httpClientErrors)[T] | string;
-    public readonly data: K;
+    public readonly data: K | undefined;
 
-    constructor({ httpCode, data, message }: { httpCode: T; data: K; message?: string }) {
+    constructor({ httpCode, data, message }: { httpCode: T; data?: K; message?: string }) {
         super();
 
         this.httpCode = httpCode;

package/src/http/index.ts

@@ -1,17 +1,31 @@
 import { HttpClientError } from "./clientError";
 import { HttpServerError } from "./serverError";
 
-export type THttpMethods = {
-    GET: "GET";
-    HEAD: "HEAD";
-    POST: "POST";
-    PUT: "PUT";
-    DELETE: "DELETE";
-    CONNECT: "CONNECT";
-    OPTIONS: "OPTIONS";
-    TRACE: "TRACE";
-    PATCH: "PATCH";
-};
+export type THttpMethods =
+    | "GET"
+    | "HEAD"
+    | "POST"
+    | "PUT"
+    | "DELETE"
+    | "CONNECT"
+    | "OPTIONS"
+    | "TRACE"
+    | "PATCH";
+
+export const httpMethods: Array<THttpMethods> = [
+    "GET",
+    "HEAD",
+    "POST",
+    "PUT",
+    "DELETE",
+    "CONNECT",
+    "OPTIONS",
+    "TRACE",
+    "PATCH"
+];
+
+export const httpMethodsStandardization = (method: string): method is THttpMethods =>
+    !!httpMethods.find((httpMethod) => httpMethod === method);
 
 export const jsonErrorInfer = (data: any, headers: Headers = new Headers()) => {
     headers.set("Content-Type", "application/json");
@@ -59,3 +73,4 @@ export const jsonErrorInfer = (data: any, headers: Headers = new Headers()) => {
 
 export * from "./clientError";
 export * from "./serverError";
+

package/src/http/serverError.ts

@@ -12,12 +12,15 @@ export const httpServerErrors = Object.freeze({
     511: "NETWORK_AUTHENTICATION_REQUIRED"
 });
 
-export class HttpServerError<T extends keyof typeof httpServerErrors = keyof typeof httpServerErrors, K = any> extends Error {
+export class HttpServerError<
+    T extends keyof typeof httpServerErrors = keyof typeof httpServerErrors,
+    K = any
+> extends Error {
     public readonly httpCode: T;
     public readonly message: (typeof httpServerErrors)[T] | string;
-    public readonly data: K;
+    public readonly data: K | undefined;
 
-    constructor({ httpCode, data, message }: { httpCode: T; data: K; message?: string }) {
+    constructor({ httpCode, data, message }: { httpCode: T; data?: K; message?: string }) {
         super();
 
         this.httpCode = httpCode;