@bool-ts/core 1.3.0 → 1.3.2

package/__test/controller.ts

@@ -13,6 +13,13 @@ const getAbcSchema = Zod.object({
     })
 });
 
+const stringSchema = Zod.object({}).refine(async (val) => {
+    const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+    await delay(10000);
+
+    return val;
+});
+
 @Controller("test")
 export class TestController {
     constructor(
@@ -56,8 +63,8 @@ export class TestController {
 
     @Delete()
     private _delete(
-        @ZodSchema(getAbcSchema) req: Request,
-        res: Response
+        req: Request,
+        @ZodSchema(stringSchema) res: Response
     ) {
         res.json({ test: "success" }).send();
     }

package/dist/decorators/http.js

@@ -2,236 +2,140 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.controllerRoutesKey = void 0;
 const http_1 = require("../http");
+const ultils_1 = require("../ultils");
 const zodSchema_1 = require("./zodSchema");
 exports.controllerRoutesKey = "__bool:controller.routes__";
-/**
- *
- * @param path
- * @returns
- */
-const Get = (path = "/") => (target, methodName, descriptor) => {
-    if (typeof descriptor.value !== "function") {
-        throw Error("Get decorator only use for method.");
+const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
+    if (!(descriptor.value instanceof Function)) {
+        throw Error(`${method} decorator only use for method.`);
     }
     // Define controller metadata
     Reflect.defineMetadata(exports.controllerRoutesKey, [
         ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
         {
             path: !path.startsWith("/") ? `/${path}` : path,
-            httpMethod: "GET",
+            httpMethod: method.toUpperCase(),
             methodName: methodName,
             descriptor: descriptor
         }
     ], target.constructor);
     // Define route parameters zod validation
     const currentMethod = descriptor.value;
-    descriptor.value = function () {
-        const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-        if (zodSchemaMetadata) {
-            for (const zodSchemaProp in zodSchemaMetadata) {
-                const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                if (!validation.success) {
-                    throw new http_1.HttpClientError({
-                        httpCode: 400,
-                        data: validation.error.issues
-                    });
+    const isAsync = descriptor.value instanceof ultils_1.AsyncFunction;
+    if (!isAsync) {
+        descriptor.value = function () {
+            const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
+            if (zodSchemaMetadata) {
+                for (const zodSchemaProp in zodSchemaMetadata) {
+                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
+                    try {
+                        const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
+                        if (!validation.success) {
+                            throw new http_1.HttpClientError({
+                                httpCode: 400,
+                                message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
+                                data: validation.error.issues
+                            });
+                        }
+                        arguments[tmpZodMetadata.index] = validation.data;
+                    }
+                    catch (error) {
+                        if (error instanceof http_1.HttpClientError) {
+                            throw error;
+                        }
+                        throw new http_1.HttpServerError({
+                            httpCode: 500,
+                            message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
+                            data: !(error instanceof Error) ? error : [{
+                                    message: error.message,
+                                    code: error.name,
+                                    cause: error.cause
+                                }]
+                        });
+                    }
                 }
             }
-        }
-        return currentMethod.apply(this, arguments);
-    };
+            return currentMethod.apply(this, arguments);
+        };
+    }
+    else {
+        descriptor.value = async function () {
+            const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
+            if (zodSchemaMetadata) {
+                for (const zodSchemaProp in zodSchemaMetadata) {
+                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
+                    try {
+                        const validation = await tmpZodMetadata.schema.safeParseAsync(arguments[tmpZodMetadata.index]);
+                        if (!validation.success) {
+                            throw new http_1.HttpClientError({
+                                httpCode: 400,
+                                message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
+                                data: validation.error.issues
+                            });
+                        }
+                        arguments[tmpZodMetadata.index] = validation.data;
+                    }
+                    catch (error) {
+                        if (error instanceof http_1.HttpClientError) {
+                            throw error;
+                        }
+                        throw new http_1.HttpServerError({
+                            httpCode: 500,
+                            message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
+                            data: !(error instanceof Error) ? error : [{
+                                    message: error.message,
+                                    code: error.name,
+                                    cause: error.cause
+                                }]
+                        });
+                    }
+                }
+            }
+            return currentMethod.apply(this, arguments);
+        };
+    }
 };
+/**
+ *
+ * @param path
+ * @returns
+ */
+const Get = (path = "/") => defaultDecorator(path, "Get");
 exports.Get = Get;
 /**
  *
  * @param path
  * @returns
  */
-const Post = (path = "/") => (target, methodName, descriptor) => {
-    if (typeof descriptor.value !== "function") {
-        throw Error("Post decorator only use for method.");
-    }
-    Reflect.defineMetadata(exports.controllerRoutesKey, [
-        ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
-        {
-            path: !path.startsWith("/") ? `/${path}` : path,
-            httpMethod: "POST",
-            methodName: methodName,
-            descriptor: descriptor
-        }
-    ], target.constructor);
-    // Define route parameters zod validation
-    const currentMethod = descriptor.value;
-    descriptor.value = function () {
-        const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-        if (zodSchemaMetadata) {
-            for (const zodSchemaProp in zodSchemaMetadata) {
-                const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                if (!validation.success) {
-                    throw new http_1.HttpClientError({
-                        httpCode: 400,
-                        data: validation.error.issues
-                    });
-                }
-            }
-        }
-        return currentMethod.apply(this, arguments);
-    };
-};
+const Post = (path = "/") => defaultDecorator(path, "Post");
 exports.Post = Post;
 /**
  *
  * @param path
  * @returns
  */
-const Put = (path = "/") => (target, methodName, descriptor) => {
-    if (typeof descriptor.value !== "function") {
-        throw Error("Put decorator only use for method.");
-    }
-    Reflect.defineMetadata(exports.controllerRoutesKey, [
-        ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
-        {
-            path: !path.startsWith("/") ? `/${path}` : path,
-            httpMethod: "PUT",
-            methodName: methodName,
-            descriptor: descriptor
-        }
-    ], target.constructor);
-    // Define route parameters zod validation
-    const currentMethod = descriptor.value;
-    descriptor.value = function () {
-        const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-        if (zodSchemaMetadata) {
-            for (const zodSchemaProp in zodSchemaMetadata) {
-                const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                if (!validation.success) {
-                    throw new http_1.HttpClientError({
-                        httpCode: 400,
-                        data: validation.error.issues
-                    });
-                }
-            }
-        }
-        return currentMethod.apply(this, arguments);
-    };
-};
+const Put = (path = "/") => defaultDecorator(path, "Put");
 exports.Put = Put;
 /**
  *
  * @param path
  * @returns
  */
-const Patch = (path = "/") => (target, methodName, descriptor) => {
-    if (typeof descriptor.value !== "function") {
-        throw Error("Patch decorator only use for method.");
-    }
-    Reflect.defineMetadata(exports.controllerRoutesKey, [
-        ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
-        {
-            path: !path.startsWith("/") ? `/${path}` : path,
-            httpMethod: "PATCH",
-            methodName: methodName,
-            descriptor: descriptor
-        }
-    ], target.constructor);
-    // Define route parameters zod validation
-    const currentMethod = descriptor.value;
-    descriptor.value = function () {
-        const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-        if (zodSchemaMetadata) {
-            for (const zodSchemaProp in zodSchemaMetadata) {
-                const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                if (!validation.success) {
-                    throw new http_1.HttpClientError({
-                        httpCode: 400,
-                        data: validation.error.issues
-                    });
-                }
-            }
-        }
-        return currentMethod.apply(this, arguments);
-    };
-};
+const Patch = (path = "/") => defaultDecorator(path, "Patch");
 exports.Patch = Patch;
 /**
  *
  * @param path
  * @returns
  */
-const Delete = (path = "/") => (target, methodName, descriptor) => {
-    if (typeof descriptor.value !== "function") {
-        throw Error("Delete decorator only use for method.");
-    }
-    Reflect.defineMetadata(exports.controllerRoutesKey, [
-        ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
-        {
-            path: !path.startsWith("/") ? `/${path}` : path,
-            httpMethod: "DELETE",
-            methodName: methodName,
-            descriptor: descriptor
-        }
-    ], target.constructor);
-    // Define route parameters zod validation
-    const currentMethod = descriptor.value;
-    descriptor.value = function () {
-        const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-        if (zodSchemaMetadata) {
-            for (const zodSchemaProp in zodSchemaMetadata) {
-                const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                if (!validation.success) {
-                    throw new http_1.HttpClientError({
-                        httpCode: 400,
-                        data: validation.error.issues
-                    });
-                }
-            }
-        }
-        return currentMethod.apply(this, arguments);
-    };
-};
+const Delete = (path = "/") => defaultDecorator(path, "Delete");
 exports.Delete = Delete;
 /**
  *
  * @param path
  * @returns
  */
-const Options = (path = "/") => (target, methodName, descriptor) => {
-    if (typeof descriptor.value !== "function") {
-        throw Error("Options decorator only use for method.");
-    }
-    Reflect.defineMetadata(exports.controllerRoutesKey, [
-        ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
-        {
-            path: !path.startsWith("/") ? `/${path}` : path,
-            httpMethod: "OPTIONS",
-            methodName: methodName,
-            descriptor: descriptor
-        }
-    ], target.constructor);
-    // Define route parameters zod validation
-    const currentMethod = descriptor.value;
-    descriptor.value = function () {
-        const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-        if (zodSchemaMetadata) {
-            for (const zodSchemaProp in zodSchemaMetadata) {
-                const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                if (!validation.success) {
-                    throw new http_1.HttpClientError({
-                        httpCode: 400,
-                        data: validation.error.issues
-                    });
-                }
-            }
-        }
-        return currentMethod.apply(this, arguments);
-    };
-};
+const Options = (path = "/") => defaultDecorator(path, "Options");
 exports.Options = Options;
 exports.default = {
     Get: exports.Get,

package/dist/decorators/zodSchema.js

@@ -3,12 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodSchema = exports.controllerRouteZodSchemaKey = void 0;
 exports.controllerRouteZodSchemaKey = "__bool:controller.route.zodSchema__";
 const ZodSchema = (schema) => {
-    try {
-        schema.safeParse(undefined);
-    }
-    catch (err) {
-        throw Error("Zod schema parameter do not allow async.");
-    }
     return (target, methodName, parameterIndex) => {
         if (!methodName) {
             return;

package/dist/hooks/factory.js

@@ -169,7 +169,9 @@ const BoolFactory = (target, options) => {
         if (!options?.debug) {
             return;
         }
-        console.error("Headers:", JSON.stringify(req.headers), "\nBody:", JSON.stringify(req.body), "\nError:", JSON.stringify(err));
+        console.info("Headers:", JSON.stringify(req.headers, null, 4), "\nBody:", JSON.stringify(req.body, null, 4));
+        console.error("Error:");
+        console.error(err);
     });
     return app;
 };

package/dist/http/clientError.d.ts

@@ -31,10 +31,11 @@ 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];
+    readonly message: typeof httpClientErrors[T] | string;
     readonly data: K;
-    constructor({ httpCode, data }: {
-        ["httpCode"]: T;
-        ["data"]: K;
+    constructor({ httpCode, data, message }: {
+        httpCode: T;
+        data: K;
+        message?: string;
     });
 }

package/dist/http/clientError.js

@@ -36,10 +36,10 @@ class HttpClientError extends Error {
     httpCode;
     message;
     data;
-    constructor({ httpCode, data }) {
+    constructor({ httpCode, data, message }) {
         super();
         this.httpCode = httpCode;
-        this.message = exports.httpClientErrors[httpCode];
+        this.message = !message?.trim() ? exports.httpClientErrors[httpCode] : message.trim();
         this.data = data;
     }
 }

package/dist/http/index.js

@@ -34,7 +34,11 @@ const errorInfer = (res, data) => {
             res.status(500).json({
                 httpCode: 500,
                 message: "INTERNAL SERVER ERROR",
-                data: data
+                data: !(data instanceof Error) ? data : {
+                    message: data.message,
+                    code: data.name,
+                    cause: data.cause
+                }
             });
             return;
         }

package/dist/http/serverError.d.ts

@@ -13,10 +13,11 @@ export declare const httpServerErrors: Readonly<{
 }>;
 export declare class HttpServerError<T extends keyof typeof httpServerErrors = keyof typeof httpServerErrors, K = any> extends Error {
     readonly httpCode: T;
-    readonly message: typeof httpServerErrors[T];
+    readonly message: typeof httpServerErrors[T] | string;
     readonly data: K;
-    constructor({ httpCode, data }: {
-        ["httpCode"]: T;
-        ["data"]: K;
+    constructor({ httpCode, data, message }: {
+        httpCode: T;
+        data: K;
+        message?: string;
     });
 }

package/dist/http/serverError.js

@@ -18,10 +18,10 @@ class HttpServerError extends Error {
     httpCode;
     message;
     data;
-    constructor({ httpCode, data }) {
+    constructor({ httpCode, data, message }) {
         super();
         this.httpCode = httpCode;
-        this.message = exports.httpServerErrors[httpCode];
+        this.message = !message?.trim() ? exports.httpServerErrors[httpCode] : message.trim();
         this.data = data;
     }
 }

package/dist/ultils/asyncFunction.d.ts

@@ -0,0 +1 @@
+export declare const AsyncFunction: Function;

package/dist/ultils/asyncFunction.js

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

package/dist/ultils/index.d.ts

@@ -0,0 +1 @@
+export * from "./asyncFunction";

package/dist/ultils/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./asyncFunction"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bool-ts/core",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/decorators/http.ts

@@ -1,4 +1,5 @@
-import { HttpClientError } from "../http";
+import { HttpClientError, HttpServerError } from "../http";
+import { AsyncFunction } from "../ultils";
 import { controllerRouteZodSchemaKey } from "./zodSchema";
 
 export interface IControllerRoute {
@@ -11,20 +12,17 @@ export interface IControllerRoute {
 
 export const controllerRoutesKey = "__bool:controller.routes__";
 
-/**
- * 
- * @param path 
- * @returns 
- */
-export const Get = (
-    path = "/"
+
+const defaultDecorator = (
+    path: string,
+    method: "Get" | "Post" | "Put" | "Patch" | "Delete" | "Options"
 ) => (
     target: Object,
     methodName: string,
     descriptor: PropertyDescriptor
 ) => {
-        if (typeof descriptor.value !== "function") {
-            throw Error("Get decorator only use for method.");
+        if (!(descriptor.value instanceof Function)) {
+            throw Error(`${method} decorator only use for method.`);
         }
 
         // Define controller metadata
@@ -32,7 +30,7 @@ export const Get = (
             ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
             {
                 path: !path.startsWith("/") ? `/${path}` : path,
-                httpMethod: "GET",
+                httpMethod: method.toUpperCase(),
                 methodName: methodName,
                 descriptor: descriptor
             }
@@ -40,80 +38,112 @@ export const Get = (
 
         // Define route parameters zod validation
         const currentMethod = descriptor.value;
-
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
-
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-
-                    const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-
-                    if (!validation.success) {
-                        throw new HttpClientError({
-                            httpCode: 400,
-                            data: validation.error.issues
-                        })
+        const isAsync = descriptor.value instanceof AsyncFunction;
+
+        if (!isAsync) {
+            descriptor.value = function () {
+                const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
+
+                if (zodSchemaMetadata) {
+                    for (const zodSchemaProp in zodSchemaMetadata) {
+                        const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
+
+                        try {
+                            const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
+
+                            if (!validation.success) {
+                                throw new HttpClientError({
+                                    httpCode: 400,
+                                    message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
+                                    data: validation.error.issues
+                                });
+                            }
+
+                            arguments[tmpZodMetadata.index] = validation.data;
+                        }
+                        catch (error) {
+                            if (error instanceof HttpClientError) {
+                                throw error;
+                            }
+
+                            throw new HttpServerError({
+                                httpCode: 500,
+                                message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
+                                data: !(error instanceof Error) ? error : [{
+                                    message: error.message,
+                                    code: error.name,
+                                    cause: error.cause
+                                }]
+                            });
+                        }
                     }
                 }
+
+                return currentMethod.apply(this, arguments);
             }
+        }
+        else {
+            descriptor.value = async function () {
+                const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
+
+                if (zodSchemaMetadata) {
+                    for (const zodSchemaProp in zodSchemaMetadata) {
+                        const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
+
+                        try {
+                            const validation = await tmpZodMetadata.schema.safeParseAsync(arguments[tmpZodMetadata.index]);
+
+                            if (!validation.success) {
+                                throw new HttpClientError({
+                                    httpCode: 400,
+                                    message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
+                                    data: validation.error.issues
+                                });
+                            }
+
+                            arguments[tmpZodMetadata.index] = validation.data;
+                        }
+                        catch (error) {
+                            if (error instanceof HttpClientError) {
+                                throw error;
+                            }
+
+                            throw new HttpServerError({
+                                httpCode: 500,
+                                message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
+                                data: !(error instanceof Error) ? error : [{
+                                    message: error.message,
+                                    code: error.name,
+                                    cause: error.cause
+                                }]
+                            });
+                        }
+                    }
+                }
 
-            return currentMethod.apply(this, arguments);
+                return currentMethod.apply(this, arguments);
+            }
         }
     }
 
-
 /**
  * 
  * @param path 
  * @returns 
  */
-export const Post = (
+export const Get = (
     path = "/"
-) => (
-    target: Object,
-    methodName: string,
-    descriptor: PropertyDescriptor
-) => {
-        if (typeof descriptor.value !== "function") {
-            throw Error("Post decorator only use for method.");
-        }
+) => defaultDecorator(path, "Get");
 
-        Reflect.defineMetadata(controllerRoutesKey, [
-            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
-            {
-                path: !path.startsWith("/") ? `/${path}` : path,
-                httpMethod: "POST",
-                methodName: methodName,
-                descriptor: descriptor
-            }
-        ], target.constructor);
-
-        // Define route parameters zod validation
-        const currentMethod = descriptor.value;
 
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
-
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-
-                    const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-
-                    if (!validation.success) {
-                        throw new HttpClientError({
-                            httpCode: 400,
-                            data: validation.error.issues
-                        })
-                    }
-                }
-            }
-
-            return currentMethod.apply(this, arguments);
-        }
-    }
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Post = (
+    path = "/"
+) => defaultDecorator(path, "Post");
 
 
 /**
@@ -123,49 +153,7 @@ export const Post = (
  */
 export const Put = (
     path = "/"
-) => (
-    target: Object,
-    methodName: string,
-    descriptor: PropertyDescriptor
-) => {
-        if (typeof descriptor.value !== "function") {
-            throw Error("Put decorator only use for method.");
-        }
-
-        Reflect.defineMetadata(controllerRoutesKey, [
-            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
-            {
-                path: !path.startsWith("/") ? `/${path}` : path,
-                httpMethod: "PUT",
-                methodName: methodName,
-                descriptor: descriptor
-            }
-        ], target.constructor);
-
-        // Define route parameters zod validation
-        const currentMethod = descriptor.value;
-
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
-
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-
-                    const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-
-                    if (!validation.success) {
-                        throw new HttpClientError({
-                            httpCode: 400,
-                            data: validation.error.issues
-                        })
-                    }
-                }
-            }
-
-            return currentMethod.apply(this, arguments);
-        }
-    }
+) => defaultDecorator(path, "Put");
 
 
 /**
@@ -175,49 +163,7 @@ export const Put = (
  */
 export const Patch = (
     path = "/"
-) => (
-    target: Object,
-    methodName: string,
-    descriptor: PropertyDescriptor
-) => {
-        if (typeof descriptor.value !== "function") {
-            throw Error("Patch decorator only use for method.");
-        }
-
-        Reflect.defineMetadata(controllerRoutesKey, [
-            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
-            {
-                path: !path.startsWith("/") ? `/${path}` : path,
-                httpMethod: "PATCH",
-                methodName: methodName,
-                descriptor: descriptor
-            }
-        ], target.constructor);
-
-        // Define route parameters zod validation
-        const currentMethod = descriptor.value;
-
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
-
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-
-                    const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-
-                    if (!validation.success) {
-                        throw new HttpClientError({
-                            httpCode: 400,
-                            data: validation.error.issues
-                        })
-                    }
-                }
-            }
-
-            return currentMethod.apply(this, arguments);
-        }
-    }
+) => defaultDecorator(path, "Patch");
 
 
 /**
@@ -227,49 +173,7 @@ export const Patch = (
  */
 export const Delete = (
     path = "/"
-) => (
-    target: Object,
-    methodName: string,
-    descriptor: PropertyDescriptor
-) => {
-        if (typeof descriptor.value !== "function") {
-            throw Error("Delete decorator only use for method.");
-        }
-
-        Reflect.defineMetadata(controllerRoutesKey, [
-            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
-            {
-                path: !path.startsWith("/") ? `/${path}` : path,
-                httpMethod: "DELETE",
-                methodName: methodName,
-                descriptor: descriptor
-            }
-        ], target.constructor);
-
-        // Define route parameters zod validation
-        const currentMethod = descriptor.value;
-
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
-
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-
-                    const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-
-                    if (!validation.success) {
-                        throw new HttpClientError({
-                            httpCode: 400,
-                            data: validation.error.issues
-                        })
-                    }
-                }
-            }
-
-            return currentMethod.apply(this, arguments);
-        }
-    }
+) => defaultDecorator(path, "Delete");
 
 
 /**
@@ -279,49 +183,7 @@ export const Delete = (
  */
 export const Options = (
     path = "/"
-) => (
-    target: Object,
-    methodName: string,
-    descriptor: PropertyDescriptor
-) => {
-        if (typeof descriptor.value !== "function") {
-            throw Error("Options decorator only use for method.");
-        }
-
-        Reflect.defineMetadata(controllerRoutesKey, [
-            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
-            {
-                path: !path.startsWith("/") ? `/${path}` : path,
-                httpMethod: "OPTIONS",
-                methodName: methodName,
-                descriptor: descriptor
-            }
-        ], target.constructor);
-
-        // Define route parameters zod validation
-        const currentMethod = descriptor.value;
-
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName);
-
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-
-                    const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-
-                    if (!validation.success) {
-                        throw new HttpClientError({
-                            httpCode: 400,
-                            data: validation.error.issues
-                        })
-                    }
-                }
-            }
-
-            return currentMethod.apply(this, arguments);
-        }
-    }
+) => defaultDecorator(path, "Options");
 
 export default {
     Get,

package/src/decorators/zodSchema.ts

@@ -2,16 +2,10 @@ import * as Zod from "zod";
 
 export const controllerRouteZodSchemaKey = "__bool:controller.route.zodSchema__";
 
+
 export const ZodSchema = (
     schema: Zod.Schema
 ) => {
-    try {
-        schema.safeParse(undefined);
-    }
-    catch (err) {
-        throw Error("Zod schema parameter do not allow async.");
-    }
-
     return (
         target: Object,
         methodName: string | symbol | undefined,

package/src/hooks/factory.ts

@@ -193,7 +193,9 @@ export const BoolFactory = (
                 return;
             }
 
-            console.error("Headers:", JSON.stringify(req.headers), "\nBody:", JSON.stringify(req.body), "\nError:", JSON.stringify(err));
+            console.info("Headers:", JSON.stringify(req.headers, null, 4), "\nBody:", JSON.stringify(req.body, null, 4));
+            console.error("Error:");
+            console.error(err);
         }
     );
 

package/src/http/clientError.ts

@@ -1,6 +1,3 @@
-import * as ExpressJS from "express";
-
-
 export const httpClientErrors = Object.freeze({
     400: "BAD_REQUEST",
     401: "UNAUTHORIZED",
@@ -38,20 +35,22 @@ export class HttpClientError<
     K = any
 > extends Error {
     public readonly httpCode: T;
-    public readonly message: typeof httpClientErrors[T];
+    public readonly message: typeof httpClientErrors[T] | string;
     public readonly data: K;
 
     constructor({
         httpCode,
-        data
+        data,
+        message
     }: {
-        ["httpCode"]: T;
-        ["data"]: K;
+        httpCode: T;
+        data: K;
+        message?: string;
     }) {
         super();
 
         this.httpCode = httpCode;
-        this.message = httpClientErrors[httpCode];
+        this.message = !message?.trim() ? httpClientErrors[httpCode] : message.trim();
         this.data = data;
     }
 }

package/src/http/index.ts

@@ -23,7 +23,11 @@ export const errorInfer = (res: Response, data: any) => {
             res.status(500).json({
                 httpCode: 500,
                 message: "INTERNAL SERVER ERROR",
-                data: data
+                data: !(data instanceof Error) ? data : {
+                    message: data.message,
+                    code: data.name,
+                    cause: data.cause
+                }
             });
             return;
         }

package/src/http/serverError.ts

@@ -1,6 +1,3 @@
-import * as ExpressJS from "express";
-
-
 export const httpServerErrors = Object.freeze({
     500: "INTERNAL_SERVER_ERROR",
     501: "NOT_IMPLEMENTED",
@@ -20,20 +17,22 @@ export class HttpServerError<
     K = any
 > extends Error {
     public readonly httpCode: T;
-    public readonly message: typeof httpServerErrors[T];
+    public readonly message: typeof httpServerErrors[T] | string;
     public readonly data: K;
 
     constructor({
         httpCode,
-        data
+        data,
+        message
     }: {
-        ["httpCode"]: T;
-        ["data"]: K;
+        httpCode: T;
+        data: K;
+        message?: string;
     }) {
         super();
 
         this.httpCode = httpCode;
-        this.message = httpServerErrors[httpCode];
+        this.message = !message?.trim() ? httpServerErrors[httpCode] : message.trim();
         this.data = data;
     }
 }

package/src/ultils/asyncFunction.ts

@@ -0,0 +1 @@
+export const AsyncFunction = async function () { }.constructor;

package/src/ultils/index.ts

@@ -0,0 +1 @@
+export * from "./asyncFunction";