@bool-ts/core 1.3.2 → 1.4.0

package/dist/ultils/index.js

@@ -1,17 +1 @@
-"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);
+export * from "./asyncFunction";

package/package.json

@@ -1,34 +1,31 @@
 {
-  "name": "@bool-ts/core",
-  "version": "1.3.2",
-  "description": "",
-  "main": "dist/index.js",
-  "scripts": {
-    "test": "bun --hot run __test/index.ts",
-    "build": "tsc"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/BoolTS/core.git"
-  },
-  "author": "Trần Đức Tâm (Neo)",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/BoolTS/core/issues"
-  },
-  "homepage": "https://github.com/BoolTS/core#readme",
-  "dependencies": {
-    "colors": "^1.4.0",
-    "express": "^5.0.0-beta.3",
-    "qs": "^6.12.1",
-    "reflect-metadata": "^0.2.2",
-    "response-time": "^2.3.2",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.21",
-    "@types/node-statsd": "^0.1.6",
-    "@types/response-time": "^2.3.8",
-    "typescript": "^5.4.5"
-  }
-}
+    "name": "@bool-ts/core",
+    "version": "1.4.0",
+    "description": "",
+    "main": "dist/index.js",
+    "scripts": {
+        "test": "bun --hot run __test/index.ts",
+        "build": "tsc"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/BoolTS/core.git"
+    },
+    "author": "Trần Đức Tâm (Neo)",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/BoolTS/core/issues"
+    },
+    "homepage": "https://github.com/BoolTS/core#readme",
+    "dependencies": {
+        "colors": "^1.4.0",
+        "qs": "^6.13.0",
+        "reflect-metadata": "^0.2.2",
+        "zod": "^3.23.8"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.1.6",
+        "@types/qs": "^6.9.15",
+        "typescript": "^5.5.4"
+    }
+}

package/src/decorators/arguments.ts

@@ -0,0 +1,128 @@
+import * as Zod from "zod";
+
+export enum EArgumentTypes {
+    headers = "HEADERS",
+    body = "BODY",
+    params = "PARAMS",
+    query = "QUERY"
+}
+
+export type TMetadata =
+    | {
+          index: number;
+          type: EArgumentTypes.headers;
+          zodSchema?: Zod.Schema;
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.body;
+          zodSchema?: Zod.Schema;
+          parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text";
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.params;
+          key?: string;
+          zodSchema?: Zod.Schema;
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.query;
+          zodSchema?: Zod.Schema;
+      };
+
+export const controllerActionArgumentsKey = Symbol.for("__bool:controller.action::arguments__");
+
+export const Headers = (zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const headersMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+
+        headersMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.headers,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TMetadata,
+            {
+                type: EArgumentTypes.headers;
+            }
+        >;
+
+        Reflect.defineMetadata(controllerActionArgumentsKey, headersMetadata, target.constructor, methodName);
+    };
+};
+
+export const Body = (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const bodyMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+
+        bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.body,
+            zodSchema: zodSchema,
+            parser: parser
+        } satisfies Extract<
+            TMetadata,
+            {
+                type: EArgumentTypes.body;
+            }
+        >;
+
+        Reflect.defineMetadata(controllerActionArgumentsKey, bodyMetadata, target.constructor, methodName);
+    };
+};
+
+export const Params = (key?: string, zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const paramsMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+
+        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.params,
+            key: key,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TMetadata,
+            {
+                type: EArgumentTypes.params;
+            }
+        >;
+
+        Reflect.defineMetadata(controllerActionArgumentsKey, paramsMetadata, target.constructor, methodName);
+    };
+};
+
+export const Query = (zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const queryMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+
+        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.params,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TMetadata,
+            {
+                type: EArgumentTypes.params;
+            }
+        >;
+
+        Reflect.defineMetadata(controllerActionArgumentsKey, queryMetadata, target.constructor, methodName);
+    };
+};

package/src/decorators/controller.ts

@@ -1,18 +1,14 @@
-import { injectableKey } from "./injectable";
-
-
-export const controllerKey = "__bool:controller__";
-
-export const Controller = (
-    prefix: string
-) => <T extends Object>(
-    target: T,
-    context?: ClassDecoratorContext
-) => {
-        Reflect.defineMetadata(controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
-        Reflect.defineMetadata(injectableKey, undefined, target);
-
-        return target;
-    }
-
-export default Controller;
+import { injectableKey } from "./injectable";
+
+export const controllerKey = Symbol.for("__bool:controller__");
+
+export const Controller =
+    (prefix: string) =>
+    <T extends Object>(target: T) => {
+        Reflect.defineMetadata(controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
+        Reflect.defineMetadata(injectableKey, undefined, target);
+
+        return target;
+    };
+
+export default Controller;

package/src/decorators/http.ts

@@ -1,195 +1,81 @@
-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";
-    methodName: string;
-    descriptor: PropertyDescriptor;
-}
-
-
-export const controllerRoutesKey = "__bool:controller.routes__";
-
-
-const defaultDecorator = (
-    path: string,
-    method: "Get" | "Post" | "Put" | "Patch" | "Delete" | "Options"
-) => (
-    target: Object,
-    methodName: string,
-    descriptor: PropertyDescriptor
-) => {
-        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: 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
-                                });
-                            }
-
-                            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);
-            }
-        }
-    }
-
-/**
- * 
- * @param path 
- * @returns 
- */
-export const Get = (
-    path = "/"
-) => defaultDecorator(path, "Get");
-
-
-/**
- * 
- * @param path 
- * @returns 
- */
-export const Post = (
-    path = "/"
-) => defaultDecorator(path, "Post");
-
-
-/**
- * 
- * @param path 
- * @returns 
- */
-export const Put = (
-    path = "/"
-) => defaultDecorator(path, "Put");
-
-
-/**
- * 
- * @param path 
- * @returns 
- */
-export const Patch = (
-    path = "/"
-) => defaultDecorator(path, "Patch");
-
-
-/**
- * 
- * @param path 
- * @returns 
- */
-export const Delete = (
-    path = "/"
-) => defaultDecorator(path, "Delete");
-
-
-/**
- * 
- * @param path 
- * @returns 
- */
-export const Options = (
-    path = "/"
-) => defaultDecorator(path, "Options");
-
-export default {
-    Get,
-    Post,
-    Put,
-    Patch,
-    Delete
-};
-
+export interface IControllerRoute {
+    path: string;
+    httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+    methodName: string;
+    descriptor: PropertyDescriptor;
+}
+
+export const controllerRoutesKey = Symbol.for("__bool:controller.routes__");
+
+const defaultDecorator =
+    (path: string, method: "Get" | "Post" | "Put" | "Patch" | "Delete" | "Options") =>
+    (target: Object, methodName: string, descriptor: PropertyDescriptor) => {
+        if (!(descriptor.value instanceof Function)) {
+            throw Error(`${method} decorator only use for class method.`);
+        }
+
+        // Define controller metadata
+        Reflect.defineMetadata(
+            controllerRoutesKey,
+            [
+                ...(Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || []),
+                {
+                    path: !path.startsWith("/") ? `/${path}` : path,
+                    httpMethod: method.toUpperCase(),
+                    methodName: methodName,
+                    descriptor: descriptor
+                }
+            ],
+            target.constructor
+        );
+    };
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Get = (path = "/") => defaultDecorator(path, "Get");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Post = (path = "/") => defaultDecorator(path, "Post");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Put = (path = "/") => defaultDecorator(path, "Put");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Patch = (path = "/") => defaultDecorator(path, "Patch");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Delete = (path = "/") => defaultDecorator(path, "Delete");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Options = (path = "/") => defaultDecorator(path, "Options");
+
+export default {
+    Get,
+    Post,
+    Put,
+    Patch,
+    Delete
+};

package/src/decorators/index.ts

@@ -1,6 +1,7 @@
-export { Controller, controllerKey } from "./controller";
-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";
+export { Headers, Body, Params, Query, EArgumentTypes } from "./arguments";
+export { Controller, controllerKey } from "./controller";
+export { Inject, injectKey } from "./inject";
+export { Injectable, injectableKey } from "./injectable";
+export { Module, moduleKey, 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

@@ -1,19 +1,13 @@
-export const injectKey = "design:paramtypes";
-
-export const Inject = <T extends Object>(
-    classDefinition: { new(...args: any[]): T }
-) => {
-    return (
-        target: Object,
-        methodName: string | symbol | undefined,
-        parameterIndex: number
-    ) => {
-        const designParameterTypes: any[] = Reflect.getMetadata(injectKey, target) || [];
-
-        designParameterTypes[parameterIndex] = classDefinition;
-
-        Reflect.defineMetadata(injectKey, designParameterTypes, target);
-    }
-}
-
-export default Inject;
+export const injectKey = "design:paramtypes";
+
+export const Inject = <T extends Object>(classDefinition: { new (...args: any[]): T }) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        const designParameterTypes: any[] = Reflect.getMetadata(injectKey, target) || [];
+
+        designParameterTypes[parameterIndex] = classDefinition;
+
+        Reflect.defineMetadata(injectKey, designParameterTypes, target);
+    };
+};
+
+export default Inject;

package/src/decorators/injectable.ts

@@ -1,12 +1,11 @@
-export const injectableKey = "__bool:injectable__";
-
-export const Injectable = () => <T extends Object>(
-    target: T,
-    context?: ClassDecoratorContext
-) => {
-    Reflect.defineMetadata(injectableKey, undefined, target);
-
-    return target;
-}
-
-export default Injectable;
+export const injectableKey = Symbol.for("__bool:injectable__");
+
+export const Injectable =
+    () =>
+    <T extends Object>(target: T) => {
+        Reflect.defineMetadata(injectableKey, undefined, target);
+
+        return target;
+    };
+
+export default Injectable;

package/src/decorators/module.ts

@@ -1,22 +1,21 @@
-export type TModuleOptions = Partial<{
-    prefix: string;
-    controllers: Array<new (...args: any[]) => unknown>;
-    dependencies: Array<new (...args: any[]) => unknown>;
-    allowOrigins: string | Array<string>;
-    allowMethods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
-}> | undefined;
-
-export const moduleKey = "__bool:module__";
-
-export const Module = (
-    args?: TModuleOptions
-) => <T extends { new(...args: any[]): {} }>(
-    target: T,
-    context?: ClassDecoratorContext
-) => {
-        Reflect.defineMetadata(moduleKey, args, target);
-
-        return target;
-    }
-
-export default Module;
+export type TModuleOptions =
+    | Partial<{
+          prefix: string;
+          controllers: Array<new (...args: any[]) => unknown>;
+          dependencies: Array<new (...args: any[]) => unknown>;
+          allowOrigins: string | Array<string>;
+          allowMethods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
+      }>
+    | undefined;
+
+export const moduleKey = Symbol.for("__bool:module__");
+
+export const Module =
+    (args?: TModuleOptions) =>
+    <T extends { new (...args: any[]): {} }>(target: T) => {
+        Reflect.defineMetadata(moduleKey, args, target);
+
+        return target;
+    };
+
+export default Module;