@bool-ts/core 1.3.2 → 1.4.1

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;

package/dist/hooks/factory.js

@@ -1,179 +1,231 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BoolFactory = void 0;
-require("reflect-metadata");
-require("colors");
-const Qs = __importStar(require("qs"));
-const ResponseTime = __importStar(require("response-time"));
-const decorators_1 = require("../decorators");
-const express_1 = __importStar(require("express"));
-const injector_1 = require("./injector");
-const http_1 = require("../http");
-/**
- *
- * @param target
- * @param router
- */
-const controllerCreator = (controllerConstructor, parentRouter = (0, express_1.Router)()) => {
-    if (!Reflect.getOwnMetadataKeys(controllerConstructor).includes(decorators_1.controllerKey)) {
+import "colors";
+import "reflect-metadata";
+import Qs from "qs";
+import * as Zod from "zod";
+import { Router, RouterGroup } from "../entities";
+import { controllerKey, controllerRoutesKey, moduleKey } from "../decorators";
+import { HttpClientError, HttpServerError, jsonErrorInfer } from "../http";
+import { Injector } from "./injector";
+import { controllerActionArgumentsKey, EArgumentTypes } from "../decorators/arguments";
+export const controllerCreator = (controllerConstructor, group) => {
+    if (!Reflect.getOwnMetadataKeys(controllerConstructor).includes(controllerKey)) {
         throw Error(`${controllerConstructor.name} is not a controller.`);
     }
-    const controller = injector_1.Injector.get(controllerConstructor);
+    const controller = Injector.get(controllerConstructor);
     if (!controller) {
         throw Error("Can not initialize controller.");
     }
-    const controllerMetadata = Reflect.getOwnMetadata(decorators_1.controllerKey, controllerConstructor) || "/";
-    const routesMetadata = (Reflect.getOwnMetadata(decorators_1.controllerRoutesKey, controllerConstructor) || []);
-    const router = (0, express_1.Router)();
-    routesMetadata.forEach(routeMetadata => {
+    const controllerMetadata = Reflect.getOwnMetadata(controllerKey, controllerConstructor) || "/";
+    const routesMetadata = (Reflect.getOwnMetadata(controllerRoutesKey, controllerConstructor) ||
+        []);
+    const router = new Router(controllerMetadata);
+    routesMetadata.forEach((routeMetadata) => {
         if (typeof routeMetadata.descriptor.value !== "function") {
             return;
         }
-        const route = router.route(routeMetadata.path);
+        const route = router.route(`/${routeMetadata.path}`);
+        const handler = routeMetadata.descriptor.value.bind(controller);
+        const routeArgument = {
+            constructor: controllerConstructor,
+            funcName: routeMetadata.methodName,
+            func: handler
+        };
         switch (routeMetadata.httpMethod) {
             case "GET":
-                return route.get(routeMetadata.descriptor.value.bind(controller));
+                return route.get(routeArgument);
             case "POST":
-                return route.post(routeMetadata.descriptor.value.bind(controller));
+                return route.post(routeArgument);
             case "PUT":
-                return route.put(routeMetadata.descriptor.value.bind(controller));
+                return route.put(routeArgument);
             case "PATCH":
-                return route.patch(routeMetadata.descriptor.value.bind(controller));
+                return route.patch(routeArgument);
             case "DELETE":
-                return route.delete(routeMetadata.descriptor.value.bind(controller));
+                return route.delete(routeArgument);
             case "OPTIONS":
-                return route.options(routeMetadata.descriptor.value.bind(controller));
+                return route.options(routeArgument);
         }
     });
-    return parentRouter.use(controllerMetadata, router);
+    return group.add(router);
 };
-/**
- *
- * @param target
- */
-const BoolFactory = (target, options) => {
-    if (!Reflect.getOwnMetadataKeys(target).includes(decorators_1.moduleKey)) {
+export const controllerActionArgumentsResolution = async (data, zodSchema, argumentIndex, funcName) => {
+    try {
+        const validation = await zodSchema.safeParseAsync(data);
+        if (!validation.success) {
+            throw new HttpClientError({
+                httpCode: 400,
+                message: `Validation at the [${funcName.toString()}] method fails at positional argument [${argumentIndex}].`,
+                data: validation.error.issues
+            });
+        }
+        return validation.data;
+    }
+    catch (error) {
+        if (error instanceof HttpClientError) {
+            throw error;
+        }
+        throw new HttpServerError({
+            httpCode: 500,
+            message: `Validation at the [${funcName.toString()}] method error at positional argument [${argumentIndex}].`,
+            data: !(error instanceof Error)
+                ? error
+                : [
+                    {
+                        message: error.message,
+                        code: error.name,
+                        cause: error.cause
+                    }
+                ]
+        });
+    }
+};
+export const BoolFactory = (target, options) => {
+    if (!Reflect.getOwnMetadataKeys(target).includes(moduleKey)) {
         throw Error(`${target.name} is not a module.`);
     }
-    const metadata = Reflect.getOwnMetadata(decorators_1.moduleKey, target);
-    const allowOrigins = !metadata?.allowOrigins ?
-        ["*"] : typeof metadata.allowOrigins !== "string" ?
-        metadata.allowOrigins : [metadata.allowOrigins];
-    const allowMethods = !metadata?.allowMethods ?
-        ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"] : metadata.allowMethods;
-    const app = (0, express_1.default)();
-    const factoryOptions = Object.freeze({
+    const moduleMetadata = Reflect.getOwnMetadata(moduleKey, target);
+    const allowOrigins = !moduleMetadata?.allowOrigins
+        ? ["*"]
+        : typeof moduleMetadata.allowOrigins !== "string"
+            ? moduleMetadata.allowOrigins
+            : [moduleMetadata.allowOrigins];
+    const allowMethods = !moduleMetadata?.allowMethods
+        ? ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+        : moduleMetadata.allowMethods;
+    const { allowLogsMethods } = Object.freeze({
         allowLogsMethods: !options?.log?.methods ? ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"] : options.log.methods
     });
-    const routers = !metadata?.controllers ?
-        [] : metadata.controllers.map(controllerConstructor => controllerCreator(controllerConstructor));
-    app.set("etag", "strong");
-    app.set("query parser", (query) => Qs.parse(query, {
-        depth: !options?.queryParser?.depth || options.queryParser.depth < 0 ? 10 : options.queryParser.depth,
-        arrayLimit: !options?.queryParser?.arrayLimit || options.queryParser.arrayLimit < 0 ? 50 : options.queryParser.arrayLimit
-    }));
-    app.use((0, express_1.urlencoded)({
-        extended: true,
-        inflate: true,
-        limit: "1mb",
-        parameterLimit: 20,
-        type: "application/x-www-form-urlencoded",
-        verify: undefined
-    }), (0, express_1.json)({
-        inflate: true,
-        limit: "5mb",
-        reviver: undefined,
-        strict: true,
-        type: "application/json",
-        verify: undefined
-    }), 
-    // Headers parser
-    (req, res, next) => {
-        for (const [key, value] of Object.entries(req.headers)) {
-            req.headers[key] = typeof value !== "string" ? value : decodeURI(value);
-        }
-        next();
-    }, 
-    // Body parser
-    (req, res, next) => {
-        if (typeof req.body !== "object" || !req.body) {
-            req.body = Object.freeze({});
-        }
-        next();
-    }, 
-    // Response time log
-    ResponseTime.default((req, res, time) => {
-        const requestMethod = req.method.toUpperCase();
-        if (!factoryOptions.allowLogsMethods.includes(requestMethod)) {
-            return;
-        }
-        const convertedMethod = `${requestMethod.yellow}`.bgBlue;
-        const convertedPID = `${process.pid}`.yellow;
-        const convertedReqIp = `${req.headers["x-forwarded-for"] || req.headers["x-real-ip"] || req.ip || "<Unknown>"}`.yellow;
-        const convertedTime = `${Math.round((time + Number.EPSILON) * 10 ** 2) / 10 ** 2}ms`.yellow;
-        console.info(`PID: ${convertedPID} - Method: ${convertedMethod} - IP: ${convertedReqIp} - ${req.originalUrl.blue} - Time: ${convertedTime}`);
-    }));
-    app.use((req, res, next) => {
-        if (!allowOrigins.includes("*")) {
-            if (!allowOrigins.includes(req.headers.origin || "*")) {
-                return res.status(403).json({
-                    httpCode: 403,
-                    data: {
-                        origin: {
-                            code: "origin:invalid:0x00001",
-                            message: "Invalid origin."
+    const routerGroup = new RouterGroup();
+    moduleMetadata?.controllers &&
+        moduleMetadata.controllers.map((controllerConstructor) => controllerCreator(controllerConstructor, routerGroup));
+    Bun.serve({
+        port: options.port,
+        async fetch(request) {
+            const start = performance.now();
+            const url = new URL(request.url);
+            try {
+                const reqHeaders = request.headers;
+                const origin = reqHeaders.get("origin");
+                if (!allowOrigins.includes("*")) {
+                    if (!origin) {
+                        throw new HttpClientError({
+                            httpCode: 403,
+                            message: "Origin not found.",
+                            data: {
+                                origin: {
+                                    code: "origin:invalid:0x00001",
+                                    message: "Origin not found."
+                                }
+                            }
+                        });
+                    }
+                    if (!allowOrigins.includes(origin)) {
+                        throw new HttpClientError({
+                            httpCode: 403,
+                            message: "Invalid origin.",
+                            data: {
+                                origin: {
+                                    code: "origin:invalid:0x00002",
+                                    message: "Invalid origin."
+                                }
+                            }
+                        });
+                    }
+                }
+                if (!allowMethods.includes(request.method.toUpperCase())) {
+                    throw new HttpClientError({
+                        httpCode: 405,
+                        message: "Method Not Allowed.",
+                        data: undefined
+                    });
+                }
+                const result = routerGroup.find(url.pathname, request.method);
+                if (!result) {
+                    throw new HttpClientError({
+                        httpCode: 404,
+                        message: "Route not found.",
+                        data: undefined
+                    });
+                }
+                const params = result.params;
+                const query = Qs.parse(url.search, options.queryParser);
+                let responseBody = undefined;
+                for (let i = 0; i < result.handlers.length; i++) {
+                    const handler = result.handlers[i];
+                    const handlerMetadata = (Reflect.getOwnMetadata(controllerActionArgumentsKey, handler.constructor, handler.funcName) || {});
+                    const controllerActionArguments = [];
+                    if (handlerMetadata) {
+                        for (const [_key, argsMetadata] of Object.entries(handlerMetadata)) {
+                            switch (argsMetadata.type) {
+                                case EArgumentTypes.headers:
+                                    controllerActionArguments[argsMetadata.index] = !argsMetadata.zodSchema
+                                        ? reqHeaders
+                                        : await controllerActionArgumentsResolution(reqHeaders, argsMetadata.zodSchema, argsMetadata.index, handler.funcName);
+                                    break;
+                                case EArgumentTypes.body:
+                                    controllerActionArguments[argsMetadata.index] = !argsMetadata.zodSchema
+                                        ? await request[argsMetadata.parser || "json"]()
+                                        : await controllerActionArgumentsResolution(await request[argsMetadata.parser || "json"](), argsMetadata.zodSchema, argsMetadata.index, handler.funcName);
+                                    break;
+                                case EArgumentTypes.params:
+                                    controllerActionArguments[argsMetadata.index] = !argsMetadata.zodSchema
+                                        ? params
+                                        : await controllerActionArgumentsResolution(params, argsMetadata.zodSchema, argsMetadata.index, handler.funcName);
+                                    break;
+                                case EArgumentTypes.query:
+                                    controllerActionArguments[argsMetadata.index] = !argsMetadata.zodSchema
+                                        ? query
+                                        : await controllerActionArgumentsResolution(query, argsMetadata.zodSchema, argsMetadata.index, handler.funcName);
+                                    break;
+                                case EArgumentTypes.param:
+                                    controllerActionArguments[argsMetadata.index] = !argsMetadata.zodSchema
+                                        ? !(argsMetadata.key in params)
+                                            ? undefined
+                                            : params[argsMetadata.key]
+                                        : await controllerActionArgumentsResolution(query, argsMetadata.zodSchema, argsMetadata.index, handler.funcName);
+                                    break;
+                                case EArgumentTypes.request:
+                                    controllerActionArguments[argsMetadata.index] = request;
+                                    break;
+                            }
                         }
                     }
+                    const responseData = await handler.func(...controllerActionArguments);
+                    if (responseData instanceof Response) {
+                        return responseData;
+                    }
+                    responseBody = responseData;
+                }
+                const resHeaders = new Headers({
+                    "Access-Control-Allow-Origin": origin || "*",
+                    "Access-Control-Allow-Headers": "*",
+                    "Access-Control-Allow-Credentials": "true",
+                    "Access-Control-Allow-Methods": allowMethods.join(", "),
+                    "Content-Type": "application/json"
+                });
+                const response = new Response(JSON.stringify({
+                    httpCode: 200,
+                    message: "Success",
+                    data: responseBody
+                }), {
+                    status: 200,
+                    statusText: "Success",
+                    headers: resHeaders
                 });
+                return response;
+            }
+            catch (error) {
+                return jsonErrorInfer(error);
+            }
+            finally {
+                const end = performance.now();
+                const convertedPID = `${process.pid}`.yellow;
+                const convertedMethod = `${request.method.yellow}`.bgBlue;
+                const convertedReqIp = `${request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || "<Unknown>"}`.yellow;
+                const convertedTime = `${Math.round((end - start + Number.EPSILON) * 10 ** 2) / 10 ** 2}ms`.yellow;
+                allowLogsMethods.includes(request.method.toUpperCase()) &&
+                    console.info(`PID: ${convertedPID} - Method: ${convertedMethod} - IP: ${convertedReqIp} - ${url.pathname.blue} - Time: ${convertedTime}`);
             }
         }
-        res.header("Access-Control-Allow-Origin", req.headers.origin || "*");
-        res.header("Access-Control-Allow-Headers", "*");
-        res.header("Access-Control-Allow-Credentials", "true");
-        res.header("Access-Control-Allow-Methods", allowMethods.join(", "));
-        next();
-    });
-    if (routers.length > 0) {
-        !metadata?.prefix ?
-            app.use(routers) : app.use(!metadata.prefix.startsWith("/") ?
-            `/${metadata.prefix}` : metadata.prefix, routers);
-    }
-    // Register error catcher
-    app.use(
-    // Error catcher
-    (err, req, res, next) => {
-        (0, http_1.errorInfer)(res, err);
-        if (!options?.debug) {
-            return;
-        }
-        console.info("Headers:", JSON.stringify(req.headers, null, 4), "\nBody:", JSON.stringify(req.body, null, 4));
-        console.error("Error:");
-        console.error(err);
     });
-    return app;
 };
-exports.BoolFactory = BoolFactory;
-exports.default = exports.BoolFactory;
+export default BoolFactory;

package/dist/hooks/index.js

@@ -1,7 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = exports.BoolFactory = void 0;
-var factory_1 = require("./factory");
-Object.defineProperty(exports, "BoolFactory", { enumerable: true, get: function () { return factory_1.BoolFactory; } });
-var injector_1 = require("./injector");
-Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return injector_1.Injector; } });
+export { BoolFactory } from "./factory";
+export { Injector } from "./injector";

package/dist/hooks/injector.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = void 0;
-require("reflect-metadata");
-const decorators_1 = require("../decorators");
-exports.Injector = new class {
+import "reflect-metadata";
+import { injectableKey, injectKey } from "../decorators";
+export const Injector = new class {
     _mapper = new Map();
     /**
      *
@@ -14,15 +11,15 @@ exports.Injector = new class {
             return this._mapper.get(classDefinition);
         }
         const ownMetadataKeys = Reflect.getMetadataKeys(classDefinition);
-        if (!ownMetadataKeys.includes(decorators_1.injectableKey)) {
+        if (!ownMetadataKeys.includes(injectableKey)) {
             throw Error("Missing dependency declaration, please check @Injectable() used on dependency(ies).");
         }
         // Initialize dependencies injection
-        const dependencies = Reflect.getOwnMetadata(decorators_1.injectKey, classDefinition) || [];
-        const injections = dependencies.map(dependency => exports.Injector.get(dependency));
+        const dependencies = Reflect.getOwnMetadata(injectKey, classDefinition) || [];
+        const injections = dependencies.map(dependency => Injector.get(dependency));
         const instance = new classDefinition(...injections);
         this._mapper.set(classDefinition, instance);
         return instance;
     }
 };
-exports.default = exports.Injector;
+export default Injector;

package/dist/http/clientError.d.ts

@@ -31,7 +31,7 @@ export declare const httpClientErrors: Readonly<{
 }>;
 export declare class HttpClientError<T extends keyof typeof httpClientErrors = keyof typeof httpClientErrors, K = any> extends Error {
     readonly httpCode: T;
-    readonly message: typeof httpClientErrors[T] | string;
+    readonly message: (typeof httpClientErrors)[T] | string;
     readonly data: K;
     constructor({ httpCode, data, message }: {
         httpCode: T;

package/dist/http/clientError.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpClientError = exports.httpClientErrors = void 0;
-exports.httpClientErrors = Object.freeze({
+export const httpClientErrors = Object.freeze({
     400: "BAD_REQUEST",
     401: "UNAUTHORIZED",
     402: "PAYMENT_REQUIRED",
@@ -32,15 +29,14 @@ exports.httpClientErrors = Object.freeze({
     431: "REQUEST_HEADER_FIELDS_TOO_LARGE",
     451: "UNAVAILABLE_FOR_LEGAL_REASONS"
 });
-class HttpClientError extends Error {
+export class HttpClientError extends Error {
     httpCode;
     message;
     data;
     constructor({ httpCode, data, message }) {
         super();
         this.httpCode = httpCode;
-        this.message = !message?.trim() ? exports.httpClientErrors[httpCode] : message.trim();
+        this.message = !message?.trim() ? httpClientErrors[httpCode] : message.trim();
         this.data = data;
     }
 }
-exports.HttpClientError = HttpClientError;

package/dist/http/index.d.ts

@@ -1,4 +1,14 @@
-import { Response } from "express";
-export declare const errorInfer: (res: Response, data: any) => void;
+export type THttpMethods = {
+    GET: "GET";
+    HEAD: "HEAD";
+    POST: "POST";
+    PUT: "PUT";
+    DELETE: "DELETE";
+    CONNECT: "CONNECT";
+    OPTIONS: "OPTIONS";
+    TRACE: "TRACE";
+    PATCH: "PATCH";
+};
+export declare const jsonErrorInfer: (data: any) => import("undici-types").Response;
 export * from "./clientError";
 export * from "./serverError";