@bool-ts/core 1.3.1 → 1.4.0

package/dist/decorators/index.js

@@ -1,26 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.controllerRouteZodSchemaKey = exports.ZodSchema = exports.controllerRoutesKey = exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.moduleKey = exports.Module = exports.injectableKey = exports.Injectable = exports.injectKey = exports.Inject = exports.controllerKey = exports.Controller = void 0;
-var controller_1 = require("./controller");
-Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return controller_1.Controller; } });
-Object.defineProperty(exports, "controllerKey", { enumerable: true, get: function () { return controller_1.controllerKey; } });
-var inject_1 = require("./inject");
-Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return inject_1.Inject; } });
-Object.defineProperty(exports, "injectKey", { enumerable: true, get: function () { return inject_1.injectKey; } });
-var injectable_1 = require("./injectable");
-Object.defineProperty(exports, "Injectable", { enumerable: true, get: function () { return injectable_1.Injectable; } });
-Object.defineProperty(exports, "injectableKey", { enumerable: true, get: function () { return injectable_1.injectableKey; } });
-var module_1 = require("./module");
-Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return module_1.Module; } });
-Object.defineProperty(exports, "moduleKey", { enumerable: true, get: function () { return module_1.moduleKey; } });
-var http_1 = require("./http");
-Object.defineProperty(exports, "Get", { enumerable: true, get: function () { return http_1.Get; } });
-Object.defineProperty(exports, "Post", { enumerable: true, get: function () { return http_1.Post; } });
-Object.defineProperty(exports, "Put", { enumerable: true, get: function () { return http_1.Put; } });
-Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return http_1.Patch; } });
-Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return http_1.Delete; } });
-Object.defineProperty(exports, "Options", { enumerable: true, get: function () { return http_1.Options; } });
-Object.defineProperty(exports, "controllerRoutesKey", { enumerable: true, get: function () { return http_1.controllerRoutesKey; } });
-var zodSchema_1 = require("./zodSchema");
-Object.defineProperty(exports, "ZodSchema", { enumerable: true, get: function () { return zodSchema_1.ZodSchema; } });
-Object.defineProperty(exports, "controllerRouteZodSchemaKey", { enumerable: true, get: function () { return zodSchema_1.controllerRouteZodSchemaKey; } });
+export { Headers, Body, Params, Query, EArgumentTypes } from "./arguments";
+export { Controller, controllerKey } from "./controller";
+export { Inject, injectKey } from "./inject";
+export { Injectable, injectableKey } from "./injectable";
+export { Module, moduleKey } from "./module";
+export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey } from "./http";
+export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";

package/dist/decorators/inject.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Inject = exports.injectKey = void 0;
-exports.injectKey = "design:paramtypes";
-const Inject = (classDefinition) => {
+export const injectKey = "design:paramtypes";
+export const Inject = (classDefinition) => {
     return (target, methodName, parameterIndex) => {
-        const designParameterTypes = Reflect.getMetadata(exports.injectKey, target) || [];
+        const designParameterTypes = Reflect.getMetadata(injectKey, target) || [];
         designParameterTypes[parameterIndex] = classDefinition;
-        Reflect.defineMetadata(exports.injectKey, designParameterTypes, target);
+        Reflect.defineMetadata(injectKey, designParameterTypes, target);
     };
 };
-exports.Inject = Inject;
-exports.default = exports.Inject;
+export default Inject;

package/dist/decorators/injectable.d.ts

@@ -1,3 +1,3 @@
-export declare const injectableKey = "__bool:injectable__";
-export declare const Injectable: () => <T extends Object>(target: T, context?: ClassDecoratorContext) => T;
+export declare const injectableKey: unique symbol;
+export declare const Injectable: () => <T extends Object>(target: T) => T;
 export default Injectable;

package/dist/decorators/injectable.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injectable = exports.injectableKey = void 0;
-exports.injectableKey = "__bool:injectable__";
-const Injectable = () => (target, context) => {
-    Reflect.defineMetadata(exports.injectableKey, undefined, target);
+export const injectableKey = Symbol.for("__bool:injectable__");
+export const Injectable = () => (target) => {
+    Reflect.defineMetadata(injectableKey, undefined, target);
     return target;
 };
-exports.Injectable = Injectable;
-exports.default = exports.Injectable;
+export default Injectable;

package/dist/decorators/module.d.ts

@@ -5,6 +5,8 @@ export type TModuleOptions = Partial<{
     allowOrigins: string | Array<string>;
     allowMethods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
 }> | undefined;
-export declare const moduleKey = "__bool:module__";
-export declare const Module: (args?: TModuleOptions) => <T extends new (...args: any[]) => {}>(target: T, context?: ClassDecoratorContext) => T;
+export declare const moduleKey: unique symbol;
+export declare const Module: (args?: TModuleOptions) => <T extends {
+    new (...args: any[]): {};
+}>(target: T) => T;
 export default Module;

package/dist/decorators/module.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = exports.moduleKey = void 0;
-exports.moduleKey = "__bool:module__";
-const Module = (args) => (target, context) => {
-    Reflect.defineMetadata(exports.moduleKey, args, target);
+export const moduleKey = Symbol.for("__bool:module__");
+export const Module = (args) => (target) => {
+    Reflect.defineMetadata(moduleKey, args, target);
     return target;
 };
-exports.Module = Module;
-exports.default = exports.Module;
+export default Module;

package/dist/decorators/zodSchema.d.ts

@@ -1,3 +1,3 @@
 import * as Zod from "zod";
-export declare const controllerRouteZodSchemaKey = "__bool:controller.route.zodSchema__";
+export declare const controllerRouteZodSchemaKey: unique symbol;
 export declare const ZodSchema: (schema: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/zodSchema.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodSchema = exports.controllerRouteZodSchemaKey = void 0;
-exports.controllerRouteZodSchemaKey = "__bool:controller.route.zodSchema__";
-const ZodSchema = (schema) => {
+import * as Zod from "zod";
+export const controllerRouteZodSchemaKey = Symbol.for("__bool:controller.route.zodSchema__");
+export const ZodSchema = (schema) => {
     return (target, methodName, parameterIndex) => {
         if (!methodName) {
             return;
         }
-        const zodSchemasMetadata = Reflect.getOwnMetadata(exports.controllerRouteZodSchemaKey, target.constructor, methodName) || {};
+        const zodSchemasMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName) || {};
         zodSchemasMetadata[`paramterIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             schema: schema
         };
-        Reflect.defineMetadata(exports.controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
     };
 };
-exports.ZodSchema = ZodSchema;

package/dist/entities/index.d.ts

@@ -0,0 +1,3 @@
+export { Route } from "./route";
+export { Router } from "./router";
+export { RouterGroup } from "./routerGroup";

package/dist/entities/index.js

@@ -0,0 +1,3 @@
+export { Route } from "./route";
+export { Router } from "./router";
+export { RouterGroup } from "./routerGroup";

package/dist/entities/route.d.ts

@@ -0,0 +1,101 @@
+import type { THttpMethods } from "../http";
+type THandler<T = unknown> = Required<{
+    constructor: new (...args: Array<any>) => T;
+    funcName: string | symbol;
+    func: (...args: Array<any>) => unknown;
+}>;
+export declare class Route {
+    static rootPattern: string;
+    readonly alias: string;
+    private _map;
+    constructor(alias: string);
+    test(pathname: string, method: keyof THttpMethods): Readonly<{
+        params: Record<string, string>;
+        handlers: Array<THandler>;
+    }> | false | undefined;
+    /**
+     *
+     */
+    isMatch(pathname: string, method: keyof THttpMethods): boolean | undefined;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    get(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    post(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    put(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    delete(...handlers: Array<THandler>): this;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    connect(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    options(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    trace(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    patch(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
+        constructor: new (...args: Array<any>) => unknown;
+        funcName: string | symbol;
+        func: (...args: Array<any>) => unknown;
+    }>[]>;
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    private _thinAlias;
+    /**
+     * Internal get fullpath after check regular expression
+     * @returns
+     */
+    get _fullPath(): string;
+    /**
+     * Internal get filterd path after check regular expression
+     * @returns
+     */
+    get _filteredPath(): string;
+}
+export default Route;

package/dist/entities/route.js

@@ -0,0 +1,257 @@
+"use strict";
+export class Route {
+    static rootPattern = ":([a-z0-9A-Z_.-]{1,})";
+    alias;
+    _map = new Map();
+    constructor(alias) {
+        this.alias = this._thinAlias(alias);
+    }
+    test(pathname, method) {
+        try {
+            const handlers = this._map.get(method);
+            const aliasSplitted = this.alias.split("/");
+            const currentPathNameSplitted = this._thinAlias(pathname).split("/");
+            if (!handlers) {
+                return undefined;
+            }
+            // Compare splitted length
+            if (aliasSplitted.length !== currentPathNameSplitted.length) {
+                return undefined;
+            }
+            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(Route.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) {
+                            Object.assign(parameters, {
+                                [key]: pathnamePart
+                            });
+                        }
+                        return match;
+                    });
+                    if (isFailed) {
+                        console.log(3, "isFailed", isFailed);
+                        return undefined;
+                    }
+                }
+                continue;
+            }
+            return Object.freeze({
+                params: parameters,
+                handlers: handlers
+            });
+        }
+        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(Route.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
+                            });
+                        }
+                        return "";
+                    });
+                    if (isFailed) {
+                        return false;
+                    }
+                }
+                continue;
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(err);
+            return undefined;
+        }
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    get(...handlers) {
+        const currentHandlers = this._map.get("GET");
+        if (!currentHandlers) {
+            this._map.set("GET", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    post(...handlers) {
+        const currentHandlers = this._map.get("POST");
+        if (!currentHandlers) {
+            this._map.set("POST", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    put(...handlers) {
+        const currentHandlers = this._map.get("PUT");
+        if (!currentHandlers) {
+            this._map.set("PUT", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    delete(...handlers) {
+        const currentHandlers = this._map.get("DELETE");
+        if (!currentHandlers) {
+            this._map.set("DELETE", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    connect(...handlers) {
+        const currentHandlers = this._map.get("CONNECT");
+        if (!currentHandlers) {
+            return this._map.set("CONNECT", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    options(...handlers) {
+        const currentHandlers = this._map.get("OPTIONS");
+        if (!currentHandlers) {
+            return this._map.set("OPTIONS", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    trace(...handlers) {
+        const currentHandlers = this._map.get("TRACE");
+        if (!currentHandlers) {
+            return this._map.set("TRACE", handlers);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param handlers
+     * @returns
+     */
+    patch(...handlers) {
+        const currentHandlers = this._map.get("PATCH");
+        if (!currentHandlers) {
+            return this._map.set("PATCH", handlers);
+        }
+        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 Route;

package/dist/entities/router.d.ts

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

package/dist/entities/router.js

@@ -0,0 +1,25 @@
+"use strict";
+import Route from "./route";
+export class Router {
+    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 Route(`${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 Router;

package/dist/entities/routerGroup.d.ts

@@ -0,0 +1,14 @@
+import type { THttpMethods } from "../http";
+import type { Router } from "./router";
+export declare class RouterGroup {
+    private _routers;
+    add(...routers: Array<Router>): this;
+    find(pathame: string, method: keyof THttpMethods): Readonly<{
+        params: Record<string, string>;
+        handlers: Array<Required<{
+            constructor: new (...args: Array<any>) => unknown;
+            funcName: string | symbol;
+            func: (...args: Array<any>) => unknown;
+        }>>;
+    }> | undefined;
+}

package/dist/entities/routerGroup.js

@@ -0,0 +1,24 @@
+export class RouterGroup {
+    _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/hooks/factory.d.ts

@@ -1,19 +1,19 @@
-import "reflect-metadata";
 import "colors";
-export type TBoolFactoryOptions = Partial<{
+import "reflect-metadata";
+import Qs from "qs";
+import * as Zod from "zod";
+import { RouterGroup } from "../entities";
+export type TBoolFactoryOptions = Required<{
+    port: number;
+}> & Partial<{
+    prefix: string;
     debug: boolean;
     log: Partial<{
         methods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
     }>;
-    queryParser: Partial<{
-        depth: 10;
-        arrayLimit: 50;
-    }>;
-    prefix: string;
+    queryParser: Parameters<typeof Qs.parse>[1];
 }>;
-/**
- *
- * @param target
- */
-export declare const BoolFactory: (target: new (...args: any[]) => unknown, options?: TBoolFactoryOptions) => import("express-serve-static-core").Express;
+export declare const controllerCreator: (controllerConstructor: new (...args: any[]) => unknown, group: RouterGroup) => RouterGroup;
+export declare const controllerActionArgumentsResolution: (data: unknown, zodSchema: Zod.Schema, argumentIndex: number, funcName: string | symbol) => Promise<any>;
+export declare const BoolFactory: (target: new (...args: any[]) => unknown, options: TBoolFactoryOptions) => void;
 export default BoolFactory;