@bool-ts/core 1.2.5 → 1.3.1

package/__test/controller.ts

@@ -1,10 +1,25 @@
 import type { IService } from "./interfaces";
 
-import { Controller, Delete, Get, Inject, Options, Patch, Post, Put } from "../src";
+import * as Zod from "zod";
+
+import { Controller, Delete, Get, Inject, Options, Patch, Post, Put, ZodSchema } from "../src";
 import { TestService } from "./service";
 import { Request, Response } from "express";
 
 
+const getAbcSchema = Zod.object({
+    headers: Zod.object({
+        authorization: Zod.string().min(10)
+    })
+});
+
+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(
@@ -13,7 +28,7 @@ export class TestController {
 
     @Get("abc")
     private _get(
-        req: Request,
+        @ZodSchema(getAbcSchema) req: Request,
         res: Response
     ) {
         console.log("this.testService", this.testService.exec())
@@ -22,7 +37,7 @@ export class TestController {
 
     @Post("abc")
     private _post(
-        req: Request,
+        @ZodSchema(getAbcSchema) req: Request,
         res: Response
     ) {
         console.log("req.body", req.body);
@@ -31,7 +46,7 @@ export class TestController {
 
     @Put()
     private _put(
-        req: Request,
+        @ZodSchema(getAbcSchema) req: Request,
         res: Response
     ) {
         res.json({ test: "success" }).send();
@@ -39,7 +54,7 @@ export class TestController {
 
     @Patch("abc/:id")
     private _patch(
-        req: Request,
+        @ZodSchema(getAbcSchema) req: Request,
         res: Response
     ) {
         console.log(req.params)
@@ -49,14 +64,14 @@ export class TestController {
     @Delete()
     private _delete(
         req: Request,
-        res: Response
+        @ZodSchema(stringSchema) res: Response
     ) {
         res.json({ test: "success" }).send();
     }
 
     @Options()
     private _options(
-        req: Request,
+        @ZodSchema(getAbcSchema) req: Request,
         res: Response
     ) {
         res.json({ test: "success" }).send();

package/dist/decorators/http.js

@@ -1,126 +1,139 @@
 "use strict";
 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;
+    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
+                            });
+                        }
+                    }
+                    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);
+        };
+    }
+    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
+                            });
+                        }
+                    }
+                    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);
-};
+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);
-};
+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);
-};
+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);
-};
+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);
-};
+const Options = (path = "/") => defaultDecorator(path, "Options");
 exports.Options = Options;
 exports.default = {
     Get: exports.Get,

package/dist/decorators/index.d.ts

@@ -3,3 +3,4 @@ export { Inject, injectKey } from "./inject";
 export { Injectable, injectableKey } from "./injectable";
 export { Module, moduleKey, type TModuleOptions } from "./module";
 export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey, type IControllerRoute } from "./http";
+export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";

package/dist/decorators/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.controllerRoutesKey = exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.moduleKey = exports.Module = exports.injectableKey = exports.Injectable = exports.injectKey = exports.Inject = exports.controllerKey = exports.Controller = void 0;
+exports.controllerRouteZodSchemaKey = exports.ZodSchema = exports.controllerRoutesKey = exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.moduleKey = exports.Module = exports.injectableKey = exports.Injectable = exports.injectKey = exports.Inject = exports.controllerKey = exports.Controller = void 0;
 var controller_1 = require("./controller");
 Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return controller_1.Controller; } });
 Object.defineProperty(exports, "controllerKey", { enumerable: true, get: function () { return controller_1.controllerKey; } });
@@ -21,3 +21,6 @@ Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { r
 Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return http_1.Delete; } });
 Object.defineProperty(exports, "Options", { enumerable: true, get: function () { return http_1.Options; } });
 Object.defineProperty(exports, "controllerRoutesKey", { enumerable: true, get: function () { return http_1.controllerRoutesKey; } });
+var zodSchema_1 = require("./zodSchema");
+Object.defineProperty(exports, "ZodSchema", { enumerable: true, get: function () { return zodSchema_1.ZodSchema; } });
+Object.defineProperty(exports, "controllerRouteZodSchemaKey", { enumerable: true, get: function () { return zodSchema_1.controllerRouteZodSchemaKey; } });

package/dist/decorators/inject.d.ts

@@ -1,5 +1,5 @@
 export declare const injectKey = "design:paramtypes";
 export declare const Inject: <T extends Object>(classDefinition: {
     new (...args: any[]): T;
-}) => (target: Object, parameterName: string | Symbol | undefined, parameterIndex: number) => void;
+}) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export default Inject;

package/dist/decorators/inject.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Inject = exports.injectKey = void 0;
 exports.injectKey = "design:paramtypes";
 const Inject = (classDefinition) => {
-    return (target, parameterName, parameterIndex) => {
+    return (target, methodName, parameterIndex) => {
         const designParameterTypes = Reflect.getMetadata(exports.injectKey, target) || [];
         designParameterTypes[parameterIndex] = classDefinition;
         Reflect.defineMetadata(exports.injectKey, designParameterTypes, target);

package/dist/decorators/zodSchema.d.ts

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

package/dist/decorators/zodSchema.js

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

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.2.5",
+  "version": "1.3.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -22,7 +22,8 @@
     "express": "^5.0.0-beta.3",
     "qs": "^6.12.1",
     "reflect-metadata": "^0.2.2",
-    "response-time": "^2.3.2"
+    "response-time": "^2.3.2",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",

package/src/decorators/http.ts

@@ -1,3 +1,7 @@
+import { HttpClientError, HttpServerError } from "../http";
+import { AsyncFunction } from "../ultils";
+import { controllerRouteZodSchemaKey } from "./zodSchema";
+
 export interface IControllerRoute {
     path: string;
     httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
@@ -8,33 +12,125 @@ 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
         Reflect.defineMetadata(controllerRoutesKey, [
             ...Reflect.getOwnMetadata(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;
+        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
+                                });
+                            }
+                        }
+                        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
+                                });
+                            }
+                        }
+                        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);
+            }
+        }
     }
 
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Get = (
+    path = "/"
+) => defaultDecorator(path, "Get");
+
 
 /**
  * 
@@ -43,25 +139,7 @@ export const Get = (
  */
 export const Post = (
     path = "/"
-) => (
-    target: Object,
-    methodName: string,
-    descriptor: PropertyDescriptor
-) => {
-        if (typeof descriptor.value !== "function") {
-            throw Error("Post decorator only use for method.");
-        }
-
-        Reflect.defineMetadata(controllerRoutesKey, [
-            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
-            {
-                path: !path.startsWith("/") ? `/${path}` : path,
-                httpMethod: "POST",
-                methodName: methodName,
-                descriptor: descriptor
-            }
-        ], target.constructor);
-    }
+) => defaultDecorator(path, "Post");
 
 
 /**
@@ -71,25 +149,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);
-    }
+) => defaultDecorator(path, "Put");
 
 
 /**
@@ -99,25 +159,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);
-    }
+) => defaultDecorator(path, "Patch");
 
 
 /**
@@ -127,25 +169,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);
-    }
+) => defaultDecorator(path, "Delete");
 
 
 /**
@@ -155,25 +179,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);
-    }
+) => defaultDecorator(path, "Options");
 
 export default {
     Get,

package/src/decorators/index.ts

@@ -3,3 +3,4 @@ export { Inject, injectKey } from "./inject";
 export { Injectable, injectableKey } from "./injectable";
 export { Module, moduleKey, type TModuleOptions } from "./module";
 export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey, type IControllerRoute } from "./http";
+export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";

package/src/decorators/inject.ts

@@ -5,7 +5,7 @@ export const Inject = <T extends Object>(
 ) => {
     return (
         target: Object,
-        parameterName: string | Symbol | undefined,
+        methodName: string | symbol | undefined,
         parameterIndex: number
     ) => {
         const designParameterTypes: any[] = Reflect.getMetadata(injectKey, target) || [];

package/src/decorators/zodSchema.ts

@@ -0,0 +1,27 @@
+import * as Zod from "zod";
+
+export const controllerRouteZodSchemaKey = "__bool:controller.route.zodSchema__";
+
+
+export const ZodSchema = (
+    schema: Zod.Schema
+) => {
+    return (
+        target: Object,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) => {
+        if (!methodName) {
+            return;
+        }
+
+        const zodSchemasMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName) || {};
+
+        zodSchemasMetadata[`paramterIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            schema: schema
+        };
+
+        Reflect.defineMetadata(controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
+    }
+}

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";