@bool-ts/core 1.8.0 → 1.8.2

package/dist/entities/httpRoute.js

@@ -1,268 +0,0 @@
-"use strict";
-export class HttpRoute {
-    static rootPattern = ":([a-z0-9A-Z_-]{1,})";
-    static innerRootPattern = "([a-z0-9A-Z_-]{1,})";
-    alias;
-    _map = new Map();
-    constructor(alias) {
-        this.alias = this._thinAlias(alias);
-    }
-    test(pathname, method) {
-        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 = 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
-            });
-        }
-        catch (err) {
-            console.error(err);
-            return false;
-        }
-    }
-    /**
-     *
-     */
-    isMatch(pathname, method) {
-        try {
-            const handlers = this._map.get(method);
-            if (!handlers) {
-                return undefined;
-            }
-            const aliasSplitted = this.alias.split("/");
-            const currentPathNameSplitted = this._thinAlias(pathname).split("/");
-            // Compare splitted length
-            if (aliasSplitted.length !== currentPathNameSplitted.length) {
-                return false;
-            }
-            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;
-                    }
-                }
-                continue;
-            }
-            return true;
-        }
-        catch (err) {
-            console.error(err);
-            return undefined;
-        }
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    get(handler) {
-        const currenTHttpRouteModel = this._map.get("GET");
-        if (!currenTHttpRouteModel) {
-            this._map.set("GET", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    post(handler) {
-        const currenTHttpRouteModel = this._map.get("POST");
-        if (!currenTHttpRouteModel) {
-            this._map.set("POST", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    put(handler) {
-        const currenTHttpRouteModel = this._map.get("PUT");
-        if (!currenTHttpRouteModel) {
-            this._map.set("PUT", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    delete(handler) {
-        const currenTHttpRouteModel = this._map.get("DELETE");
-        if (!currenTHttpRouteModel) {
-            this._map.set("DELETE", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    connect(handler) {
-        const currenTHttpRouteModel = this._map.get("CONNECT");
-        if (!currenTHttpRouteModel) {
-            return this._map.set("CONNECT", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    options(handler) {
-        const currenTHttpRouteModel = this._map.get("OPTIONS");
-        if (!currenTHttpRouteModel) {
-            return this._map.set("OPTIONS", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    trace(handler) {
-        const currenTHttpRouteModel = this._map.get("TRACE");
-        if (!currenTHttpRouteModel) {
-            return this._map.set("TRACE", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    patch(handler) {
-        const currenTHttpRouteModel = this._map.get("PATCH");
-        if (!currenTHttpRouteModel) {
-            return this._map.set("PATCH", handler);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param handlers
-     * @returns
-     */
-    _thinAlias(alias) {
-        return alias
-            .replace(new RegExp("[/]{2,}", "g"), "/")
-            .replace(new RegExp("^[/]|[/]$", "g"), "");
-    }
-    /**
-     * Internal get fullpath after check regular expression
-     * @returns
-     */
-    get _fullPath() {
-        // Split path to start filter
-        const pathSplited = this.alias.split("/");
-        const blockFiltered = pathSplited.map((value, index) => {
-            // Initialize full parameter regex to validate
-            let validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})(\\(.*?\\))", "g");
-            if (!validateReg.test(value)) {
-                // Initialize key parameter regex to validate
-                validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})", "g");
-                if (!validateReg.test(value)) {
-                    return value;
-                }
-                return value.replace(validateReg, (value, index) => `${value}(.*?)`);
-            }
-            return value;
-        });
-        return blockFiltered.join("/");
-    }
-    /**
-     * Internal get filterd path after check regular expression
-     * @returns
-     */
-    get _filteredPath() {
-        // Split path to start filter
-        const pathSplited = this.alias.split("/");
-        //
-        const blockFiltered = pathSplited.map((value, index) => {
-            let validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})((.*?))", "g");
-            if (!validateReg.test(value)) {
-                // Initialize key parameter regex to validate
-                validateReg = new RegExp(":([a-z0-9A-Z_.-]{1,})", "g");
-                if (!validateReg.test(value)) {
-                    return value;
-                }
-                return value.replace(validateReg, (value, index) => "(.*?)");
-            }
-            return value.replace(validateReg, (subString, arg_01, arg_02) => arg_02);
-        });
-        return blockFiltered.join("/");
-    }
-}
-export default HttpRoute;

package/dist/entities/httpRouter.js

@@ -1,27 +0,0 @@
-"use strict";
-import HttpRoute from "./httpRoute";
-export class HttpRouter {
-    alias;
-    _routes = new Map();
-    constructor(alias) {
-        this.alias = this._thinAlias(alias);
-    }
-    route(alias) {
-        const thinAlias = this._thinAlias(`${this.alias}/${alias}`);
-        const route = this._routes.get(thinAlias);
-        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"), "");
-    }
-    get routes() {
-        return this._routes;
-    }
-}
-export default HttpRouter;

package/dist/entities/httpRouterGroup.js

@@ -1,24 +0,0 @@
-export class HttpRouterGroup {
-    _routers = new Map();
-    add(...routers) {
-        for (let i = 0; i < routers.length; i++) {
-            if (this._routers.has(routers[i].alias)) {
-                continue;
-            }
-            this._routers.set(routers[i].alias, routers[i]);
-        }
-        return this;
-    }
-    find(pathame, method) {
-        for (const router of [...this._routers.values()]) {
-            for (const route of router.routes.values()) {
-                const result = route.test(pathame, method);
-                if (!result) {
-                    continue;
-                }
-                return result;
-            }
-        }
-        return undefined;
-    }
-}

package/dist/entities/index.js

@@ -1,6 +0,0 @@
-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.js

@@ -1,15 +0,0 @@
-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.js

@@ -1,54 +0,0 @@
-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.js

@@ -1,51 +0,0 @@
-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"), "");
-    }
-}