@bool-ts/core 1.6.1 → 1.6.2

package/src/decorators/arguments.ts

@@ -1,87 +1,84 @@
 import * as Zod from "zod";
-
-export enum EArgumentTypes {
-    requestHeaders = "REQUEST_HEADERS",
-    body = "BODY",
-    params = "PARAMS",
-    param = "PARAM",
-    query = "QUERY",
-    request = "REQUEST",
-    responseHeaders = "RESPONSE_HEADERS",
-    config = "CONFIG"
-}
+import {
+    argumentsKey,
+    bodyArgsKey,
+    contextArgsKey,
+    paramArgsKey,
+    paramsArgsKey,
+    queryArgsKey,
+    requestArgsKey,
+    requestHeadersArgsKey,
+    responseHeadersArgsKey
+} from "../keys";
 
 export type TArgumentsMetadata =
     | {
           index: number;
-          type: EArgumentTypes.requestHeaders;
+          type: typeof requestHeadersArgsKey;
           zodSchema?: Zod.Schema;
       }
     | {
           index: number;
-          type: EArgumentTypes.body;
+          type: typeof bodyArgsKey;
           zodSchema?: Zod.Schema;
           parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text";
       }
     | {
           index: number;
-          type: EArgumentTypes.params;
+          type: typeof paramsArgsKey;
           zodSchema?: Zod.Schema;
       }
     | {
           index: number;
-          type: EArgumentTypes.param;
+          type: typeof paramArgsKey;
           key: string;
           zodSchema?: Zod.Schema;
       }
     | {
           index: number;
-          type: EArgumentTypes.query;
+          type: typeof queryArgsKey;
           zodSchema?: Zod.Schema;
       }
     | {
           index: number;
-          type: EArgumentTypes.request;
+          type: typeof requestArgsKey;
           zodSchema?: Zod.Schema;
       }
     | {
           index: number;
-          type: EArgumentTypes.responseHeaders;
+          type: typeof responseHeadersArgsKey;
           zodSchema?: Zod.Schema;
       }
     | {
           index: number;
-          type: EArgumentTypes.config;
-          zodSchema?: Zod.Schema;
+          type: typeof contextArgsKey;
       };
 
-export const argumentsKey = Symbol.for("__bool:arguments__");
-
-export const RequestHeaders = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+export const RequestHeaders =
+    (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const headersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const requestHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        headersMetadata[`argumentIndexes.${parameterIndex}`] = {
+        requestHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.requestHeaders,
+            type: requestHeadersArgsKey,
             zodSchema: zodSchema
         } satisfies Extract<
             TArgumentsMetadata,
             {
-                type: EArgumentTypes.requestHeaders;
+                type: typeof requestHeadersArgsKey;
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, headersMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, requestHeadersMetadata, target.constructor, methodName);
     };
-};
 
-export const Body = (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+export const Body =
+    (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
@@ -90,19 +87,18 @@ export const Body = (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "
 
         bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.body,
+            type: bodyArgsKey,
             zodSchema: zodSchema,
             parser: parser
         } satisfies Extract<
             TArgumentsMetadata,
             {
-                type: EArgumentTypes.body;
+                type: typeof bodyArgsKey;
             }
         >;
 
         Reflect.defineMetadata(argumentsKey, bodyMetadata, target.constructor, methodName);
     };
-};
 
 export const Params =
     (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
@@ -114,44 +110,44 @@ export const Params =
 
         paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.params,
+            type: paramsArgsKey,
             zodSchema: zodSchema
         } satisfies Extract<
             TArgumentsMetadata,
             {
-                type: EArgumentTypes.params;
+                type: typeof paramsArgsKey;
             }
         >;
 
         Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
     };
 
-export const Param = (key: string, zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+export const Param =
+    (key: string, zodSchema?: Zod.Schema) =>
+    (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const paramMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+        paramMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.param,
+            type: paramArgsKey,
             key: key,
             zodSchema: zodSchema
         } satisfies Extract<
             TArgumentsMetadata,
             {
-                type: EArgumentTypes.param;
+                type: typeof paramArgsKey;
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, paramMetadata, target.constructor, methodName);
     };
-};
 
-export const Query = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+export const Query =
+    (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
@@ -160,84 +156,78 @@ export const Query = (zodSchema?: Zod.Schema) => {
 
         queryMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.query,
+            type: queryArgsKey,
             zodSchema: zodSchema
         } satisfies Extract<
             TArgumentsMetadata,
             {
-                type: EArgumentTypes.query;
+                type: typeof queryArgsKey;
             }
         >;
 
         Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
     };
-};
 
-export const Request = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+export const Request =
+    (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const requestMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+        requestMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.request,
+            type: requestArgsKey,
             zodSchema: zodSchema
         } satisfies Extract<
             TArgumentsMetadata,
             {
-                type: EArgumentTypes.request;
+                type: typeof requestArgsKey;
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, requestMetadata, target.constructor, methodName);
     };
-};
 
-export const ResponseHeaders = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+export const ResponseHeaders =
+    (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
         }
 
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+        responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.responseHeaders,
+            type: responseHeadersArgsKey,
             zodSchema: zodSchema
         } satisfies Extract<
             TArgumentsMetadata,
             {
-                type: EArgumentTypes.responseHeaders;
+                type: typeof responseHeadersArgsKey;
             }
         >;
 
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
     };
-};
 
-export const Config = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
+export const Context = () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+    if (!methodName) {
+        return;
+    }
 
-        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    const responseHeadersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
 
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.config,
-            zodSchema: zodSchema
-        } satisfies Extract<
-            TArgumentsMetadata,
-            {
-                type: EArgumentTypes.config;
-            }
-        >;
+    responseHeadersMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: contextArgsKey
+    } satisfies Extract<
+        TArgumentsMetadata,
+        {
+            type: typeof contextArgsKey;
+        }
+    >;
 
-        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
-    };
+    Reflect.defineMetadata(argumentsKey, responseHeadersMetadata, target.constructor, methodName);
 };

package/src/decorators/controller.ts

@@ -1,13 +1,12 @@
 import type { IController } from "../interfaces/controller";
-import { controllerHttpKey, type THttpMetadata } from "./http";
+import { controllerHttpKey, controllerKey } from "../keys";
+import { type THttpMetadata } from "./http";
 
 export type TControllerMetadata = Required<{
     prefix: string;
     httpMetadata: THttpMetadata;
 }>;
 
-export const controllerKey = Symbol.for("__bool:controller__");
-
 export const Controller =
     (prefix: string) =>
     <T extends { new (...args: any[]): IController }>(target: T) => {

package/src/decorators/dispatcher.ts

@@ -1,9 +1,8 @@
 import type { IDispatcher } from "../interfaces/dispatcher";
+import { dispatcherKey } from "../keys";
 
 export type TDispatcherMetadata = undefined;
 
-export const dispatcherKey = Symbol.for("__bool:dispatcher__");
-
 export const Dispatcher =
     () =>
     <T extends { new (...args: any[]): IDispatcher }>(target: T) => {

package/src/decorators/guard.ts

@@ -1,9 +1,8 @@
 import type { IGuard } from "../interfaces";
+import { guardKey } from "../keys";
 
 export type TGuardMetadata = undefined;
 
-export const guardKey = Symbol.for("__bool:guard__");
-
 export const Guard =
     () =>
     <T extends { new (...args: any[]): IGuard }>(target: T) => {

package/src/decorators/http.ts

@@ -1,3 +1,5 @@
+import { controllerHttpKey } from "../keys";
+
 export type TRoute = {
     path: string;
     httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
@@ -7,8 +9,6 @@ export type TRoute = {
 
 export type THttpMetadata = Array<TRoute>;
 
-export const controllerHttpKey = Symbol.for("__bool:controller.http__");
-
 const defaultDecorator =
     (path: string, method: "Get" | "Post" | "Put" | "Patch" | "Delete" | "Options") =>
     (target: Object, methodName: string, descriptor: PropertyDescriptor) => {

package/src/decorators/index.ts

@@ -1,24 +1,13 @@
-export {
-    Body,
-    Config,
-    Params,
-    Param,
-    Query,
-    Request,
-    RequestHeaders,
-    ResponseHeaders,
-    EArgumentTypes,
-    argumentsKey
-} from "./arguments";
-export { Controller, controllerKey } from "./controller";
-export { Guard, guardKey } from "./guard";
-export { Inject, injectKey } from "./inject";
-export { Injectable, injectableKey } from "./injectable";
-export { Middleware, middlewareKey } from "./middleware";
-export { Module, moduleKey } from "./module";
-export { Get, Post, Put, Patch, Delete, Options, controllerHttpKey } from "./http";
-export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";
-export { Dispatcher, dispatcherKey } from "./dispatcher";
+export { Body, Params, Param, Query, Request, RequestHeaders, ResponseHeaders } from "./arguments";
+export { Controller } from "./controller";
+export { Guard } from "./guard";
+export { Inject } from "./inject";
+export { Injectable } from "./injectable";
+export { Middleware } from "./middleware";
+export { Module } from "./module";
+export { Get, Post, Put, Patch, Delete, Options } from "./http";
+export { ZodSchema } from "./zodSchema";
+export { Dispatcher } from "./dispatcher";
 
 export type { TControllerMetadata } from "./controller";
 export type { TModuleMetadata, TModuleOptions } from "./module";

package/src/decorators/inject.ts

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

package/src/decorators/injectable.ts

@@ -1,4 +1,4 @@
-export const injectableKey = Symbol.for("__bool:injectable__");
+import { injectableKey } from "../keys";
 
 export const Injectable =
     () =>

package/src/decorators/middleware.ts

@@ -1,9 +1,8 @@
 import type { IMiddleware } from "../interfaces";
+import { middlewareKey } from "../keys";
 
 export type TMiddlewareMetadata = undefined;
 
-export const middlewareKey = Symbol.for("__bool:middleware__");
-
 export const Middleware =
     () =>
     <T extends { new (...args: any[]): IMiddleware }>(target: T) => {

package/src/decorators/module.ts

@@ -1,42 +1,42 @@
 import type { IModule } from "../interfaces/module";
-import { controllerKey } from "./controller";
-import { dispatcherKey } from "./dispatcher";
-import { guardKey } from "./guard";
-import { injectableKey } from "./injectable";
-import { middlewareKey } from "./middleware";
+import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey } 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 TModuleOptions =
+export type TModuleOptions<TConfig extends {} = {}> =
     | Partial<{
-          config: Record<string | symbol, any> | (() => Record<string | symbol, any> | Promise<Record<string | symbol, any>>);
+          config: TConfig | (() => TConfig | Promise<TConfig>);
           prefix: string;
           dependencies: TInstances;
-          controllers: TInstances;
+          loaders: TLoaders<TConfig>;
           middlewares: TInstances;
           guards: TInstances;
           beforeDispatchers: TInstances;
+          controllers: TInstances;
           afterDispatchers: TInstances;
       }>
     | undefined;
 
-export type TModuleMetadata =
+export type TModuleMetadata<TConfig extends {} = {}> =
     | Partial<{
-          config: Record<string | symbol, any> | (() => Record<string | symbol, any> | Promise<Record<string | symbol, any>>);
+          config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
           prefix: string;
-          controllers: TInstances;
           dependencies: TInstances;
+          loaders: TLoaders<TConfig>;
           middlewares: TInstances;
           guards: TInstances;
           beforeDispatchers: TInstances;
+          controllers: TInstances;
           afterDispatchers: TInstances;
       }>
     | undefined;
 
-export const moduleKey = Symbol.for("__bool:module__");
-
 export const Module =
-    (args?: TModuleOptions) =>
+    <TConfig extends {} = {}>(args?: TModuleOptions<TConfig>) =>
     <T extends { new (...args: any[]): IModule }>(target: T) => {
         const { middlewares, guards, beforeDispatchers, controllers, afterDispatchers, dependencies } = args || {};
 

package/src/decorators/zodSchema.ts

@@ -1,6 +1,5 @@
 import * as Zod from "zod";
-
-export const controllerRouteZodSchemaKey = Symbol.for("__bool:controller.route.zodSchema__");
+import { controllerRouteZodSchemaKey } from "../keys";
 
 export const ZodSchema = (schema: Zod.Schema) => {
     return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {