@bool-ts/core 1.8.2 → 1.9.1

package/dist/keys/index.d.ts

@@ -9,6 +9,7 @@ export declare const injectKey: unique symbol;
 export declare const injectableKey: unique symbol;
 export declare const middlewareKey: unique symbol;
 export declare const moduleKey: unique symbol;
+export declare const containerKey: unique symbol;
 export declare const zodSchemaKey: unique symbol;
 export declare const webSocketKey: unique symbol;
 export declare const webSocketEventKey: unique symbol;

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@bool-ts/core",
-    "version": "1.8.2",
+    "version": "1.9.1",
     "description": "",
     "main": "dist/index.js",
     "scripts": {
         "test": "bun --hot run __test/index.ts",
-        "build": "tsc --emitDeclarationOnly && bun build ./src/index.ts --outdir ./dist"
+        "build": "tsc --emitDeclarationOnly && bun build ./src/index.ts --outdir ./dist --minify"
     },
     "repository": {
         "type": "git",
@@ -19,14 +19,14 @@
     "homepage": "https://github.com/BoolTS/core#readme",
     "dependencies": {
         "@bool-ts/date-time": "^1.0.0",
-        "qs": "^6.13.1",
+        "qs": "^6.14.0",
         "reflect-metadata": "^0.2.2",
         "zod": "^3.24.1"
     },
     "devDependencies": {
         "@types/bun": "latest",
-        "@types/qs": "^6.9.17",
-        "typescript": "^5.7.2"
+        "@types/qs": "^6.9.18",
+        "typescript": "^5.7.3"
     },
     "private": "false"
 }

package/src/decorators/arguments.ts

@@ -66,15 +66,19 @@ export type TArgumentsMetadata =
           type: typeof routeModelArgsKey;
       };
 
+export type TArgumentsMetadataCollection = Record<`argumentIndexes.${number}`, TArgumentsMetadata>;
+
 export const RequestHeaders =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const requestHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        requestHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestHeadersArgsKey,
             zodSchema: schema
@@ -85,18 +89,20 @@ export const RequestHeaders =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, requestHeadersMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const RequestHeader =
-    (key: string, schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (key: string, schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const requestHeaderMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        requestHeaderMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestHeaderArgsKey,
             key: key,
@@ -108,7 +114,7 @@ export const RequestHeader =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, requestHeaderMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const RequestBody =
@@ -118,9 +124,10 @@ export const RequestBody =
             return;
         }
 
-        const bodyMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestBodyArgsKey,
             zodSchema: schema,
@@ -132,18 +139,20 @@ export const RequestBody =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, bodyMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Params =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: paramsArgsKey,
             zodSchema: schema
@@ -154,18 +163,20 @@ export const Params =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Param =
-    (key: string, schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (key: string, schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const paramMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        paramMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: paramArgsKey,
             key: key,
@@ -177,18 +188,20 @@ export const Param =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, paramMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Query =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: queryArgsKey,
             zodSchema: schema
@@ -199,18 +212,20 @@ export const Query =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
 export const Request =
-    (schema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    (schema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const requestMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        requestMetadata[`argumentIndexes.${parameterIndex}`] = {
+        metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: requestArgsKey,
             zodSchema: schema
@@ -221,66 +236,73 @@ export const Request =
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, requestMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
 
-export const ResponseHeaders = () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-    if (!methodName) {
-        return;
-    }
+export const ResponseHeaders =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
 
-    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: responseHeadersArgsKey
-    } satisfies Extract<
-        TArgumentsMetadata,
-        {
-            type: typeof responseHeadersArgsKey;
-        }
-    >;
-
-    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
-};
-
-export const Context = (key?: symbol) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-    if (!methodName) {
-        return;
-    }
-
-    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
-
-    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: contextArgsKey,
-        key: key
-    } satisfies Extract<
-        TArgumentsMetadata,
-        {
-            type: typeof contextArgsKey;
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: responseHeadersArgsKey
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof responseHeadersArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };
+
+export const Context =
+    (key?: symbol) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
         }
-    >;
 
-    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
-};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-export const RouteModel = () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-    if (!methodName) {
-        return;
-    }
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: contextArgsKey,
+            key: key
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof contextArgsKey;
+            }
+        >;
 
-    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };
 
-    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
-        index: parameterIndex,
-        type: routeModelArgsKey
-    } satisfies Extract<
-        TArgumentsMetadata,
-        {
-            type: typeof routeModelArgsKey;
+export const RouteModel =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
         }
-    >;
 
-    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
-};
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: routeModelArgsKey
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof routeModelArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };

package/src/decorators/container.ts

@@ -0,0 +1,79 @@
+import type { IModule } from "../interfaces";
+
+import { containerKey, dispatcherKey, guardKey, injectableKey, middlewareKey } from "../keys";
+
+type TInstances = Array<new (...args: any[]) => any>;
+type TLoaders<TConfig extends {} = {}> = Record<
+    string | symbol,
+    (args: { config: TConfig }) => [string | symbol, any] | Promise<[string | symbol, any]>
+>;
+
+export type TContainerOptions<TConfig extends {} = {}> =
+    | (Required<{
+          modules: TInstances;
+      }> &
+          Partial<{
+              config: TConfig | (() => TConfig | Promise<TConfig>);
+              dependencies: TInstances;
+              loaders: TLoaders<TConfig>;
+              middlewares: TInstances;
+              guards: TInstances;
+              dispatchers: TInstances;
+          }>)
+    | undefined;
+
+export type TContainerMetadata<TConfig extends {} = {}> =
+    | (Required<{
+          modules: TInstances;
+      }> &
+          Partial<{
+              config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
+              dependencies: TInstances;
+              loaders: TLoaders<TConfig>;
+              middlewares: TInstances;
+              guards: TInstances;
+              dispatchers: TInstances;
+          }>)
+    | undefined;
+
+export const Container =
+    <TConfig extends {} = {}>(args?: TContainerOptions<TConfig>) =>
+    <T extends { new (...args: any[]): IModule }>(target: T) => {
+        const { middlewares, guards, dispatchers, dependencies } = args || {};
+
+        if (middlewares) {
+            for (let i = 0; i < middlewares.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(middlewares[i]).includes(middlewareKey)) {
+                    throw Error(`${middlewares[i].name} is not a middleware.`);
+                }
+            }
+        }
+
+        if (guards) {
+            for (let i = 0; i < guards.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(guards[i]).includes(guardKey)) {
+                    throw Error(`${guards[i].name} is not a guard.`);
+                }
+            }
+        }
+
+        if (dispatchers) {
+            for (let i = 0; i < dispatchers.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(dispatchers[i]).includes(dispatcherKey)) {
+                    throw Error(`${dispatchers[i].name} is not a dispatcher.`);
+                }
+            }
+        }
+
+        if (dependencies) {
+            for (let i = 0; i < dependencies.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(dependencies[i]).includes(injectableKey)) {
+                    throw Error(`${dependencies[i].name} is not an injectable.`);
+                }
+            }
+        }
+
+        Reflect.defineMetadata(containerKey, args, target);
+    };
+
+export default Container;

package/src/decorators/controller.ts

@@ -13,7 +13,7 @@ export const Controller =
     <T extends { new (...args: any[]): IController }>(target: T) => {
         const metadata: TControllerMetadata = {
             prefix: !prefix?.startsWith("/") ? `/${prefix || ""}` : prefix,
-            httpMetadata: [...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || [])]
+            httpMetadata: [...(Reflect.getOwnMetadata(controllerHttpKey, target) || [])]
         };
 
         Reflect.defineMetadata(controllerKey, metadata, target);

package/src/decorators/http.ts

@@ -1,10 +1,13 @@
-import { controllerHttpKey } from "../keys";
+import type { TArgumentsMetadataCollection } from "./arguments";
+
+import { argumentsKey, controllerHttpKey } from "../keys";
 
 export type TRoute = {
     path: string;
     httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
     methodName: string;
     descriptor: TypedPropertyDescriptor<any>;
+    argumentsMetadata: TArgumentsMetadataCollection;
 };
 
 export type THttpMetadata = Array<TRoute>;
@@ -16,13 +19,17 @@ const defaultDecorator =
             throw Error(`${method} decorator only use for class method.`);
         }
 
+        const argumentsMetadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
         const metadata: THttpMetadata = [
             ...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || []),
             {
                 path: !path.startsWith("/") ? `/${path}` : path,
                 httpMethod: method.toUpperCase(),
                 methodName: methodName,
-                descriptor: descriptor
+                descriptor: descriptor,
+                argumentsMetadata: argumentsMetadata
             }
         ];
 

package/src/decorators/module.ts

@@ -1,6 +1,14 @@
 import type { IModule } from "../interfaces";
 
-import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey, webSocketKey } from "../keys";
+import {
+    controllerKey,
+    dispatcherKey,
+    guardKey,
+    injectableKey,
+    middlewareKey,
+    moduleKey,
+    webSocketKey
+} from "../keys";
 
 type TInstances = Array<new (...args: any[]) => any>;
 type TLoaders<TConfig extends {} = {}> = Record<
@@ -39,7 +47,8 @@ export type TModuleMetadata<TConfig extends {} = {}> =
 export const Module =
     <TConfig extends {} = {}>(args?: TModuleOptions<TConfig>) =>
     <T extends { new (...args: any[]): IModule }>(target: T) => {
-        const { middlewares, guards, dispatchers, controllers, dependencies, webSockets } = args || {};
+        const { middlewares, guards, dispatchers, controllers, dependencies, webSockets } =
+            args || {};
 
         if (middlewares) {
             for (let i = 0; i < middlewares.length; i++) {

package/src/decorators/webSocket.ts

@@ -1,5 +1,6 @@
 import type { Server } from "bun";
 import type { IWebSocket } from "../interfaces";
+import type { TArgumentsMetadataCollection } from "./arguments";
 import type { TWebSocketEventMetadata } from "./webSocketEvent";
 
 import { webSocketEventKey, webSocketKey } from "../keys";
@@ -9,6 +10,7 @@ export type TWebSocketHttpRouteMetadata = {
     httpMethod: "GET" | "POST";
     methodName: symbol;
     descriptor: PropertyDescriptor;
+    argumentsMetadata: TArgumentsMetadataCollection;
 };
 
 export type TWebSocketUpgradeData = {
@@ -59,13 +61,15 @@ export const WebSocket =
                       path: "/",
                       httpMethod: "GET",
                       methodName: upgradeHandlerSymbol,
-                      descriptor: descriptor
+                      descriptor: descriptor,
+                      argumentsMetadata: {}
                   },
                   {
                       path: "/",
                       httpMethod: "POST",
                       methodName: upgradeHandlerSymbol,
-                      descriptor: descriptor
+                      descriptor: descriptor,
+                      argumentsMetadata: {}
                   }
               ];
 

package/src/entities/httpRoute.ts

@@ -1,11 +1,13 @@
 "use strict";
 
+import type { TArgumentsMetadataCollection } from "../decorators/arguments";
 import type { THttpMethods } from "../http";
 
 export type THttpRouteModel<T = unknown> = Readonly<{
     class: new (...args: Array<any>) => T;
     funcName: string | symbol;
     func: (...args: Array<any>) => unknown;
+    argumentsMetadata: TArgumentsMetadataCollection;
 }>;
 
 export class HttpRoute {