@bool-ts/core 1.8.1 → 1.9.0

package/dist/decorators/http.js

@@ -1,60 +0,0 @@
-import { controllerHttpKey } from "../keys";
-const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
-    if (!(descriptor?.value instanceof Function)) {
-        throw Error(`${method} decorator only use for class method.`);
-    }
-    const metadata = [
-        ...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || []),
-        {
-            path: !path.startsWith("/") ? `/${path}` : path,
-            httpMethod: method.toUpperCase(),
-            methodName: methodName,
-            descriptor: descriptor
-        }
-    ];
-    // Define controller metadata
-    Reflect.defineMetadata(controllerHttpKey, metadata, target.constructor);
-};
-/**
- *
- * @param path
- * @returns
- */
-export const Get = (path = "/") => defaultDecorator(path, "Get");
-/**
- *
- * @param path
- * @returns
- */
-export const Post = (path = "/") => defaultDecorator(path, "Post");
-/**
- *
- * @param path
- * @returns
- */
-export const Put = (path = "/") => defaultDecorator(path, "Put");
-/**
- *
- * @param path
- * @returns
- */
-export const Patch = (path = "/") => defaultDecorator(path, "Patch");
-/**
- *
- * @param path
- * @returns
- */
-export const Delete = (path = "/") => defaultDecorator(path, "Delete");
-/**
- *
- * @param path
- * @returns
- */
-export const Options = (path = "/") => defaultDecorator(path, "Options");
-export default {
-    Get,
-    Post,
-    Put,
-    Patch,
-    Delete
-};

package/dist/decorators/index.js

@@ -1,13 +0,0 @@
-export { Context, Param, Params, Query, Request, RequestBody, RequestHeader, RequestHeaders, ResponseHeaders, RouteModel } from "./arguments";
-export { Controller } from "./controller";
-export { Dispatcher } from "./dispatcher";
-export { Guard } from "./guard";
-export { Delete, Get, Options, Patch, Post, Put } from "./http";
-export { Inject } from "./inject";
-export { Injectable } from "./injectable";
-export { Middleware } from "./middleware";
-export { Module } from "./module";
-export { WebSocket } from "./webSocket";
-export { WebSocketCloseCode, WebSocketCloseReason, WebSocketConnection, WebSocketServer } from "./webSocketArguments";
-export { WebSocketEvent } from "./webSocketEvent";
-export { ZodSchema } from "./zodSchema";

package/dist/decorators/inject.js

@@ -1,9 +0,0 @@
-import { injectKey } from "../keys";
-export const Inject = (definition) => {
-    return (target, methodName, parameterIndex) => {
-        const designParameterTypes = Reflect.getMetadata(injectKey, target) || [];
-        designParameterTypes[parameterIndex] = definition;
-        Reflect.defineMetadata(injectKey, designParameterTypes, target);
-    };
-};
-export default Inject;

package/dist/decorators/injectable.js

@@ -1,3 +0,0 @@
-import { injectableKey } from "../keys";
-export const Injectable = () => (target) => Reflect.defineMetadata(injectableKey, undefined, target);
-export default Injectable;

package/dist/decorators/middleware.js

@@ -1,6 +0,0 @@
-import { middlewareKey } from "../keys";
-export const Middleware = () => (target) => {
-    const metadata = undefined;
-    Reflect.defineMetadata(middlewareKey, metadata, target);
-};
-export default Middleware;

package/dist/decorators/module.js

@@ -1,48 +0,0 @@
-import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey, webSocketKey } from "../keys";
-export const Module = (args) => (target) => {
-    const { middlewares, guards, dispatchers, controllers, dependencies, webSockets } = args || {};
-    if (middlewares) {
-        for (let i = 0; i < middlewares.length; i++) {
-            if (!Reflect.getOwnMetadataKeys(middlewares[i]).includes(middlewareKey)) {
-                throw Error(`${middlewares[i].name} is not a middleware.`);
-            }
-        }
-    }
-    if (guards) {
-        for (let i = 0; i < guards.length; i++) {
-            if (!Reflect.getOwnMetadataKeys(guards[i]).includes(guardKey)) {
-                throw Error(`${guards[i].name} is not a guard.`);
-            }
-        }
-    }
-    if (dispatchers) {
-        for (let i = 0; i < dispatchers.length; i++) {
-            if (!Reflect.getOwnMetadataKeys(dispatchers[i]).includes(dispatcherKey)) {
-                throw Error(`${dispatchers[i].name} is not a dispatcher.`);
-            }
-        }
-    }
-    if (controllers) {
-        for (let i = 0; i < controllers.length; i++) {
-            if (!Reflect.getOwnMetadataKeys(controllers[i]).includes(controllerKey)) {
-                throw Error(`${controllers[i].name} is not a controller.`);
-            }
-        }
-    }
-    if (dependencies) {
-        for (let i = 0; i < dependencies.length; i++) {
-            if (!Reflect.getOwnMetadataKeys(dependencies[i]).includes(injectableKey)) {
-                throw Error(`${dependencies[i].name} is not an injectable.`);
-            }
-        }
-    }
-    if (webSockets) {
-        for (let i = 0; i < webSockets.length; i++) {
-            if (!Reflect.getOwnMetadataKeys(webSockets[i]).includes(webSocketKey)) {
-                throw Error(`${webSockets[i].name} is not a websocket gateway.`);
-            }
-        }
-    }
-    Reflect.defineMetadata(moduleKey, args, target);
-};
-export default Module;

package/dist/decorators/webSocket.js

@@ -1,40 +0,0 @@
-import { webSocketEventKey, webSocketKey } from "../keys";
-const upgradeHandlerSymbol = Symbol("__bool:webSocket.upgrade__");
-const upgradeHandler = (server, request, query) => {
-    const url = new URL(request.url);
-    return server.upgrade(request, {
-        data: {
-            method: request.method.toUpperCase(),
-            pathname: url.pathname,
-            query: query
-        }
-    });
-};
-export const WebSocket = (args) => (target) => {
-    const { prefix } = args || {};
-    target.prototype[upgradeHandlerSymbol] = upgradeHandler;
-    const descriptor = Object.getOwnPropertyDescriptor(target.prototype, upgradeHandlerSymbol);
-    const httpMetadata = !descriptor
-        ? []
-        : [
-            {
-                path: "/",
-                httpMethod: "GET",
-                methodName: upgradeHandlerSymbol,
-                descriptor: descriptor
-            },
-            {
-                path: "/",
-                httpMethod: "POST",
-                methodName: upgradeHandlerSymbol,
-                descriptor: descriptor
-            }
-        ];
-    const metadata = {
-        prefix: !prefix?.startsWith("/") ? `/${prefix || ""}` : prefix,
-        events: Reflect.getOwnMetadata(webSocketEventKey, target) || {},
-        http: httpMetadata
-    };
-    Reflect.defineMetadata(webSocketKey, metadata, target);
-};
-export default WebSocket;

package/dist/decorators/webSocketArguments.js

@@ -1,49 +0,0 @@
-import { webSocketCloseCodeArgsKey, webSocketCloseReasonArgsKey, webSocketConnectionArgsKey, webSocketEventArgumentsKey, webSocketMessageArgsKey, webSocketServerArgsKey } from "../keys";
-export const WebSocketConnection = () => (target, methodName, parameterIndex) => {
-    if (!methodName) {
-        return;
-    }
-    const webSocketEventArgumentsMetadata = Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
-        {};
-    webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: webSocketConnectionArgsKey
-    };
-    Reflect.defineMetadata(webSocketEventArgumentsKey, webSocketEventArgumentsMetadata, target.constructor, methodName);
-};
-export const WebSocketServer = () => (target, methodName, parameterIndex) => {
-    if (!methodName) {
-        return;
-    }
-    const webSocketEventArgumentsMetadata = Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
-        {};
-    webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: webSocketServerArgsKey
-    };
-    Reflect.defineMetadata(webSocketEventArgumentsKey, webSocketEventArgumentsMetadata, target.constructor, methodName);
-};
-export const WebSocketCloseCode = () => (target, methodName, parameterIndex) => {
-    if (!methodName) {
-        return;
-    }
-    const webSocketEventArgumentsMetadata = Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
-        {};
-    webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: webSocketCloseCodeArgsKey
-    };
-    Reflect.defineMetadata(webSocketEventArgumentsKey, webSocketEventArgumentsMetadata, target.constructor, methodName);
-};
-export const WebSocketCloseReason = () => (target, methodName, parameterIndex) => {
-    if (!methodName) {
-        return;
-    }
-    const webSocketEventArgumentsMetadata = Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
-        {};
-    webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: webSocketCloseReasonArgsKey
-    };
-    Reflect.defineMetadata(webSocketEventArgumentsKey, webSocketEventArgumentsMetadata, target.constructor, methodName);
-};

package/dist/decorators/webSocketEvent.js

@@ -1,24 +0,0 @@
-import { webSocketEventArgumentsKey, webSocketEventKey } from "../keys";
-/**
- *
- * @param path
- * @returns
- */
-export const WebSocketEvent = (eventName) => (target, methodName, descriptor) => {
-    if (!(descriptor.value instanceof Function)) {
-        throw Error("WebSocketEvent decorator only use for class's method.");
-    }
-    const webSocketEventArgumentsMetadata = Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName);
-    const webSocketEventMetadata = Object.freeze({
-        methodName: methodName,
-        descriptor: descriptor,
-        arguments: webSocketEventArgumentsMetadata
-    });
-    const webSocketMetadata = {
-        ...(Reflect.getOwnMetadata(webSocketEventKey, target.constructor) || undefined),
-        [eventName]: webSocketEventMetadata
-    };
-    Reflect.defineMetadata(webSocketEventKey, webSocketEventMetadata, target.constructor, methodName);
-    Reflect.defineMetadata(webSocketEventKey, webSocketMetadata, target.constructor);
-};
-export default WebSocket;

package/dist/decorators/zodSchema.js

@@ -1,15 +0,0 @@
-import * as Zod from "zod";
-import { zodSchemaKey } from "../keys";
-export const ZodSchema = (schema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const zodSchemasMetadata = Reflect.getOwnMetadata(zodSchemaKey, target.constructor, methodName) || {};
-        zodSchemasMetadata[`paramterIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            schema: schema
-        };
-        Reflect.defineMetadata(zodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
-    };
-};

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,22 +0,0 @@
-export class WebSocketRoute {
-    eventName;
-    metadata;
-    _context = undefined;
-    constructor({ eventName, metadata }) {
-        this.eventName = eventName;
-        this.metadata = metadata;
-    }
-    bind(instance) {
-        this._context = instance;
-        return this;
-    }
-    execute() {
-        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/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.execute());
-        }
-        return map;
-    }
-    /**
-     * Handle alias for router, standardize
-     * @param alias
-     * @returns
-     */
-    static thinAlias(alias) {
-        return alias
-            .replace(new RegExp("[/]{2,}", "g"), "/")
-            .replace(new RegExp("^[/]|[/]$", "g"), "");
-    }
-}