@bool-ts/core 1.3.1 → 1.4.0

package/dist/hooks/factory.js

@@ -1,179 +1,208 @@
-"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 headers = request.headers;
+                const origin = headers.get("origin");
+                const response = new Response();
+                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."
+                                }
+                            }
+                        });
+                    }
+                }
+                response.headers.set("Access-Control-Allow-Origin", origin || "*");
+                response.headers.set("Access-Control-Allow-Headers", "*");
+                response.headers.set("Access-Control-Allow-Credentials", "true");
+                response.headers.set("Access-Control-Allow-Methods", allowMethods.join(", "));
+                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);
+                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
+                                        ? headers
+                                        : await controllerActionArgumentsResolution(headers, 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;
+                            }
                         }
                     }
-                });
+                    const response = await handler.func(...controllerActionArguments);
+                    if (response instanceof Response) {
+                        return response;
+                    }
+                }
+                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";

package/dist/http/index.js

@@ -1,80 +1,41 @@
-"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]; } };
+import { HttpClientError } from "./clientError";
+import { HttpServerError } from "./serverError";
+export const jsonErrorInfer = (data) => {
+    const headers = new Headers();
+    headers.append("Content-Type", "application/json");
+    if (data instanceof HttpClientError || data instanceof HttpServerError) {
+        return new Response(JSON.stringify(data), {
+            status: data.httpCode,
+            statusText: data.message,
+            headers: headers
+        });
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorInfer = void 0;
-const clientError_1 = require("./clientError");
-const serverError_1 = require("./serverError");
-const errorInfer = (res, data) => {
-    if (res.headersSent) {
-        return;
-    }
-    try {
-        if (data instanceof clientError_1.HttpClientError) {
-            res.status(data.httpCode).json(data);
-            return;
-        }
-        if (data instanceof serverError_1.HttpServerError) {
-            res.status(data.httpCode).json(data);
-            return;
-        }
-        if (typeof data === "object") {
-            res.status(500).json({
-                httpCode: 500,
-                message: "INTERNAL SERVER ERROR",
-                data: !(data instanceof Error) ? data : {
-                    message: data.message,
-                    code: data.name,
-                    cause: data.cause
-                }
-            });
-            return;
-        }
+    return new Response(JSON.stringify((() => {
         switch (typeof data) {
+            case "object":
+                return !(data instanceof Error)
+                    ? data
+                    : {
+                        message: data.message,
+                        code: data.name,
+                        cause: data.cause
+                    };
             case "string":
-                res.status(500).json({
-                    httpCode: 500,
-                    message: "INTERNAL SERVER ERROR",
-                    data: {
-                        message: data
-                    }
-                });
-                return;
+                return {
+                    message: data
+                };
             case "number":
-                res.status(500).json({
-                    httpCode: 500,
-                    message: "INTERNAL SERVER ERROR",
-                    data: {
-                        code: data
-                    }
-                });
-                return;
+                return {
+                    code: data
+                };
             default:
-                res.status(500).json({
-                    httpCode: 500,
-                    message: "INTERNAL SERVER ERROR",
-                    data: undefined
-                });
-                return;
+                return undefined;
         }
-    }
-    catch (error) {
-        console.error(JSON.stringify(error));
-        res.end();
-    }
+    })()), {
+        status: 500,
+        statusText: "INTERNAL SERVER ERROR",
+        headers: headers
+    });
 };
-exports.errorInfer = errorInfer;
-__exportStar(require("./clientError"), exports);
-__exportStar(require("./serverError"), exports);
+export * from "./clientError";
+export * from "./serverError";

package/dist/http/serverError.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpServerError = exports.httpServerErrors = void 0;
-exports.httpServerErrors = Object.freeze({
+export const httpServerErrors = Object.freeze({
     500: "INTERNAL_SERVER_ERROR",
     501: "NOT_IMPLEMENTED",
     502: "BAD_GATEWAY",
@@ -14,15 +11,14 @@ exports.httpServerErrors = Object.freeze({
     510: "NOT_EXTENDED",
     511: "NETWORK_AUTHENTICATION_REQUIRED"
 });
-class HttpServerError extends Error {
+export class HttpServerError extends Error {
     httpCode;
     message;
     data;
     constructor({ httpCode, data, message }) {
         super();
         this.httpCode = httpCode;
-        this.message = !message?.trim() ? exports.httpServerErrors[httpCode] : message.trim();
+        this.message = !message?.trim() ? httpServerErrors[httpCode] : message.trim();
         this.data = data;
     }
 }
-exports.HttpServerError = HttpServerError;

package/dist/index.js

@@ -1,21 +1,5 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-__exportStar(require("./interfaces"), exports);
-__exportStar(require("./hooks"), exports);
-__exportStar(require("./decorators"), exports);
-__exportStar(require("./http"), exports);
+import "reflect-metadata";
+export * from "./interfaces";
+export * from "./hooks";
+export * from "./decorators";
+export * from "./http";

package/dist/interfaces/index.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {};
+export default {};

package/dist/ultils/asyncFunction.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncFunction = void 0;
-exports.AsyncFunction = async function () { }.constructor;
+export const AsyncFunction = async function () { }.constructor;