@bool-ts/core 2.2.4 → 2.3.1

package/dist/interfaces/@types.d.ts

@@ -0,0 +1,114 @@
+import type { BunFile } from "bun";
+import type { TArgumentsMetadataCollection, TWebSocketEventHandlerMetadata } from "../decorators";
+import type { HttpRouterGroup, THttpRouteModel, WebSocketRouterGroup } from "../entities";
+import type { THttpMethods } from "../http";
+import type { ICustomValidator } from "./customValidator";
+import type { IGuard } from "./guard";
+import type { IInterceptor } from "./interceptor";
+import type { IMiddleware } from "./middleware";
+import { parse as QsParse } from "qs";
+export type THandlerMetadata<TClass extends Object = Object, TFuncName extends keyof TClass = keyof TClass, TFunc = TClass[TFuncName]> = Readonly<{
+    class: TClass;
+    func: TFunc;
+    funcName: TFuncName;
+    argumentsMetadata: TArgumentsMetadataCollection;
+}>;
+export type TStartMiddlewareHandlers = THandlerMetadata<IMiddleware, "start", NonNullable<IMiddleware["start"]>>[];
+export type TEndMiddlewareHandlers = THandlerMetadata<IMiddleware, "end", NonNullable<IMiddleware["end"]>>[];
+export type TGuardHandlers = THandlerMetadata<IGuard, "enforce", NonNullable<IGuard["enforce"]>>[];
+export type TOpenInterceptorHandlers = THandlerMetadata<IInterceptor, "open", NonNullable<IInterceptor["open"]>>[];
+export type TCloseInterceptorHandlers = THandlerMetadata<IInterceptor, "close", NonNullable<IInterceptor["close"]>>[];
+export type TControllerHandlers = THttpRouteModel[];
+export type TStartMiddlewaresPipe = {
+    type: "START_MIDDLEWARES";
+    handlers: TStartMiddlewareHandlers;
+};
+export type TEndMiddlewaresPipe = {
+    type: "END_MIDDLEWARES";
+    handlers: TEndMiddlewareHandlers;
+};
+export type TGuardsPipe = {
+    type: "GUARDS";
+    handlers: TGuardHandlers;
+};
+export type TOpenInterceptorsPipe = {
+    type: "OPEN_INTERCEPTORS";
+    handlers: TOpenInterceptorHandlers;
+};
+export type TCloseInterceptorsPipe = {
+    type: "CLOSE_INTERCEPTORS";
+    handlers: TCloseInterceptorHandlers;
+};
+export type TControllerPipe = {
+    type: "CONTROLLER";
+    handlers?: undefined;
+};
+export type TPipesEnforcerUnion = TStartMiddlewaresPipe | TEndMiddlewaresPipe | TGuardsPipe | TOpenInterceptorsPipe | TCloseInterceptorsPipe | TControllerPipe;
+export type TParamsType = Record<string, string>;
+export type TApplicationOptions<AllowedMethods extends Array<THttpMethods> = Array<THttpMethods>> = Required<{
+    port: number;
+}> & Partial<{
+    config: Record<string | symbol, any> | (() => Record<string | symbol, any>);
+    prefix: string;
+    debug: boolean;
+    log: Partial<{
+        methods: AllowedMethods;
+    }>;
+    queryParser: Parameters<typeof QsParse>[1];
+    static: Required<{
+        path: string;
+    }> & Partial<{
+        headers: TParamsType;
+        cacheTimeInSeconds: number;
+    }>;
+    cors: Partial<{
+        credentials: boolean;
+        origins: string | Array<string>;
+        methods: Array<THttpMethods>;
+        headers: Array<string>;
+    }>;
+    pipelineStrategy: {
+        type: "SIMPLE";
+        targets: Partial<{
+            middlewares: "FIFO" | "FILO";
+            interceptors: "FIFO" | "FILO";
+        }>;
+    };
+}>;
+export type TStaticMap = Map<string, Readonly<{
+    expiredAt: Date;
+    file: BunFile;
+}>>;
+export type TResolutedOptions = Readonly<{
+    allowLogsMethods: Array<THttpMethods>;
+    allowOrigins: Array<string>;
+    allowMethods: Array<THttpMethods>;
+    allowHeaders: Array<string>;
+    allowCredentials: boolean;
+    staticOption?: Required<{
+        path: string;
+    }> & Partial<{
+        headers: TParamsType;
+        cacheTimeInSeconds: number;
+    }>;
+    pipelineStrategy: Required<{
+        startMiddlewares: "FIFO" | "FILO";
+        endMiddlewares: "FIFO" | "FILO";
+        openInterceptors: "FIFO" | "FILO";
+        closeInterceptors: "FIFO" | "FILO";
+    }>;
+}>;
+export type TWebSocketUpgradeData = {
+    pathname: string;
+    method: string;
+    query: Record<string, unknown>;
+};
+export type TPreLaunch = undefined | Readonly<{
+    startMiddlewareHandlers: TStartMiddlewareHandlers;
+    endMiddlewareHandlers: TEndMiddlewareHandlers;
+    controllerRouterGroup: HttpRouterGroup;
+    webSocketHttpRouterGroup: HttpRouterGroup;
+    webSocketRouterGroup: WebSocketRouterGroup;
+    webSocketsMap: Map<string, TWebSocketEventHandlerMetadata>;
+}>;
+export type TValidator = undefined | ICustomValidator;

package/dist/interfaces/guard.d.ts

@@ -1,3 +1,4 @@
+export type TGuardReturn = boolean | "UNAUTHORIZATION" | "FORBIDDEN" | Promise<boolean | "UNAUTHORIZATION" | "FORBIDDEN">;
 export interface IGuard {
-    enforce(...args: any[]): boolean | Promise<boolean>;
+    enforce(...args: any[]): TGuardReturn;
 }

package/dist/interfaces/index.d.ts

@@ -1,8 +1,9 @@
+export type { TApplicationOptions, TCloseInterceptorHandlers, TCloseInterceptorsPipe, TControllerHandlers, TControllerPipe, TEndMiddlewareHandlers, TEndMiddlewaresPipe, TGuardHandlers, TGuardsPipe, THandlerMetadata, TOpenInterceptorHandlers, TOpenInterceptorsPipe, TParamsType, TPipesEnforcerUnion, TPreLaunch, TResolutedOptions, TStartMiddlewareHandlers, TStartMiddlewaresPipe, TStaticMap, TValidator, TWebSocketUpgradeData } from "./@types";
 export type { IContainer } from "./container";
 export type { IContext, TContextOptions } from "./context";
 export type { IController } from "./controller";
 export type { ICustomValidator } from "./customValidator";
-export type { IGuard } from "./guard";
+export type { IGuard, TGuardReturn } from "./guard";
 export type { IInterceptor } from "./interceptor";
 export type { IMiddleware } from "./middleware";
 export type { IModule } from "./module";

package/dist/producers/factory.d.ts

@@ -1,5 +1,5 @@
 import type { TArgumentsMetadataCollection } from "../decorators/arguments";
-import type { TConstructor } from "../ultils";
+import type { TConstructor } from "../utils";
 import "reflect-metadata";
 import Qs from "qs";
 import { Application } from "../entities";

package/dist/utils/asyncFunction.d.ts

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

package/dist/utils/colors.d.ts

@@ -0,0 +1,30 @@
+type AnsiOptions = {
+    color?: keyof typeof ansiColors;
+    backgroundColor?: keyof typeof backgroundColors;
+    bold?: boolean;
+    underline?: boolean;
+};
+declare const ansiColors: Readonly<{
+    black: "38;5;16";
+    red: "38;5;196";
+    green: "38;5;46";
+    yellow: "38;5;226";
+    blue: "38;5;21";
+    magenta: "38;5;201";
+    cyan: "38;5;51";
+    white: "38;5;231";
+    gray: "38;5;244";
+}>;
+declare const backgroundColors: Readonly<{
+    black: "48;5;16";
+    red: "48;5;196";
+    green: "48;5;46";
+    yellow: "48;5;226";
+    blue: "48;5;21";
+    magenta: "48;5;201";
+    cyan: "48;5;51";
+    white: "48;5;231";
+    gray: "48;5;244";
+}>;
+export declare const ansiText: (text: string, options?: AnsiOptions) => string;
+export {};

package/dist/utils/functions.d.ts

@@ -0,0 +1 @@
+export declare const inferStatusText: (httpCode: number) => string;

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./asyncFunction";
+export * from "./colors";
+export * from "./constructor";
+export * from "./functions";
+export * from "./socket";

package/dist/utils/socket.d.ts

@@ -0,0 +1 @@
+export declare const isWebSocketUpgrade: (request: Request) => boolean;

package/package.json

@@ -5,9 +5,9 @@
     },
     "dependencies": {
         "@bool-ts/date-time": "^1.0.0",
-        "qs": "^6.14.0",
+        "qs": "^6.14.1",
         "reflect-metadata": "^0.2.2",
-        "zod": "^4.2.1"
+        "zod": "^4.3.4"
     },
     "description": "Core package for BoolTS framework",
     "devDependencies": {
@@ -40,8 +40,9 @@
     },
     "scripts": {
         "build": "tsc --emitDeclarationOnly && bun run app.build.ts",
-        "test": "bun --hot run __test/index.ts"
+        "test:server": "bun --hot run __test/server/index.ts",
+        "test:socket": "bun --hot run __test/client/socket.ts"
     },
     "types": "./dist/index.d.ts",
-    "version": "2.2.4"
+    "version": "2.3.1"
 }

package/src/constants/index.ts

@@ -0,0 +1,10 @@
+export * as Keys from "./keys";
+export * as Objects from "./objects";
+
+export type {
+    TClientErrorStatuses,
+    TInformationalStatuses,
+    TRedirectionStatuses,
+    TServerErrorStatuses,
+    TSuccessfulStatuses
+} from "./objects";

package/src/constants/objects.ts

@@ -0,0 +1,291 @@
+//#region [Informational]
+export const informationalStatuses = Object.freeze({
+    CONTINUE: Object.freeze({
+        status: 100,
+        statusText: "Continue"
+    }),
+    SWITCHING_PROTOCOLS: Object.freeze({
+        status: 101,
+        statusText: "Switching Protocols"
+    }),
+    EARLY_HINTS: Object.freeze({
+        status: 103,
+        statusText: "Early Hints"
+    })
+});
+
+export type TInformationalStatuses =
+    (typeof informationalStatuses)[keyof typeof informationalStatuses]["status"];
+//#endregion
+
+//#region [Successful]
+export const successfulStatuses = Object.freeze({
+    OK: Object.freeze({
+        status: 200,
+        statusText: "OK"
+    }),
+    CREATED: Object.freeze({
+        status: 201,
+        statusText: "Created"
+    }),
+    ACCEPTED: Object.freeze({
+        status: 202,
+        statusText: "Accepted"
+    }),
+    NON_AUTHORITATIVE_INFORMATION: Object.freeze({
+        status: 203,
+        statusText: "Non-Authoritative Information"
+    }),
+    NO_CONTENT: Object.freeze({
+        status: 204,
+        statusText: "No Content"
+    }),
+    RESET_CONTENT: Object.freeze({
+        status: 205,
+        statusText: "Reset Content"
+    }),
+    PARTIAL_CONTENT: Object.freeze({
+        status: 206,
+        statusText: "Partial Content"
+    }),
+    MULTI_STATUS: Object.freeze({
+        status: 207,
+        statusText: "Multi-Status"
+    }),
+    ALREADY_REPORTED: Object.freeze({
+        status: 208,
+        statusText: "Already Reported"
+    }),
+    IM_USED: Object.freeze({
+        status: 226,
+        statusText: "IM Used"
+    })
+});
+
+export type TSuccessfulStatuses =
+    (typeof successfulStatuses)[keyof typeof successfulStatuses]["status"];
+//#endregion
+
+//#region [Redirection]
+export const redirectionStatuses = Object.freeze({
+    MULTIPLE_CHOICES: Object.freeze({
+        status: 300,
+        statusText: "Multiple Choices"
+    }),
+    MOVED_PERMANENTLY: Object.freeze({
+        status: 301,
+        statusText: "Moved Permanently"
+    }),
+    FOUND: Object.freeze({
+        status: 302,
+        statusText: "Found"
+    }),
+    SEE_OTHER: Object.freeze({
+        status: 303,
+        statusText: "See Other"
+    }),
+    NOT_MODIFIED: Object.freeze({
+        status: 304,
+        statusText: "Not Modified"
+    }),
+    UNUSED: Object.freeze({
+        status: 306,
+        statusText: "Unused"
+    }),
+    TEMPORARY_REDIRECT: Object.freeze({
+        status: 307,
+        statusText: "Temporary Redirect"
+    }),
+    PERMANENT_REDIRECT: Object.freeze({
+        status: 308,
+        statusText: "Permanent Redirect"
+    })
+});
+
+export type TRedirectionStatuses =
+    (typeof redirectionStatuses)[keyof typeof redirectionStatuses]["status"];
+//#endregion
+
+//#region [Client error]
+export const clientErrorStatuses = Object.freeze({
+    BAD_REQUEST: Object.freeze({
+        status: 400,
+        statusText: "Bad Request"
+    }),
+    UNAUTHORIZED: Object.freeze({
+        status: 401,
+        statusText: "Unauthorized"
+    }),
+    PAYMENT_REQUIRED: Object.freeze({
+        status: 402,
+        statusText: "Payment Required"
+    }),
+    FORBIDDEN: Object.freeze({
+        status: 403,
+        statusText: "Forbidden"
+    }),
+    NOT_FOUND: Object.freeze({
+        status: 404,
+        statusText: "Not Found"
+    }),
+    METHOD_NOT_ALLOWED: Object.freeze({
+        status: 405,
+        statusText: "Method Not Allowed"
+    }),
+    NOT_ACCEPTABLE: Object.freeze({
+        status: 406,
+        statusText: "Not Acceptable"
+    }),
+    PROXY_AUTHENTICATION_REQUIRED: Object.freeze({
+        status: 407,
+        statusText: "Proxy Authentication Required"
+    }),
+    REQUEST_TIMEOUT: Object.freeze({
+        status: 408,
+        statusText: "Request Timeout"
+    }),
+    CONFLICT: Object.freeze({
+        status: 409,
+        statusText: "Conflict"
+    }),
+    GONE: Object.freeze({
+        status: 410,
+        statusText: "Gone"
+    }),
+    LENGTH_REQUIRED: Object.freeze({
+        status: 411,
+        statusText: "Length Required"
+    }),
+    PRECONDITION_FAILED: Object.freeze({
+        status: 412,
+        statusText: "Precondition Failed"
+    }),
+    CONTENT_TOO_LARGE: Object.freeze({
+        status: 413,
+        statusText: "Content Too Large"
+    }),
+    URI_TOO_LONG: Object.freeze({
+        status: 414,
+        statusText: "URI Too Long"
+    }),
+    UNSUPPORTED_MEDIA_TYPE: Object.freeze({
+        status: 415,
+        statusText: "Unsupported Media Type"
+    }),
+    RANGE_NOT_SATISFIABLE: Object.freeze({
+        status: 416,
+        statusText: "Range Not Satisfiable"
+    }),
+    EXPECTATION_FAILED: Object.freeze({
+        status: 417,
+        statusText: "Expectation Failed"
+    }),
+    I_AM_A_TEAPOT: Object.freeze({
+        status: 418,
+        statusText: "I'm a teapot"
+    }),
+    MISDIRECTED_REQUEST: Object.freeze({
+        status: 421,
+        statusText: "Misdirected Request"
+    }),
+    UNPROCESSABLE_CONTENT: Object.freeze({
+        status: 422,
+        statusText: "Unprocessable Content"
+    }),
+    LOCKED: Object.freeze({
+        status: 423,
+        statusText: "Locked"
+    }),
+    FAILED_DEPENDENCY: Object.freeze({
+        status: 424,
+        statusText: "Failed Dependency"
+    }),
+    TOO_EARLY: Object.freeze({
+        status: 425,
+        statusText: "Too Early"
+    }),
+    UPGRADE_REQUIRED: Object.freeze({
+        status: 426,
+        statusText: "Upgrade Required"
+    }),
+    PRECONDITION_REQUIRED: Object.freeze({
+        status: 428,
+        statusText: "Precondition Required"
+    }),
+    TOO_MANY_REQUESTS: Object.freeze({
+        status: 429,
+        statusText: "Too Many Requests"
+    }),
+    REQUEST_HEADER_FIELDS_TOO_LARGE: Object.freeze({
+        status: 431,
+        statusText: "Request Header Fields Too Large"
+    }),
+    UNAVAILABLE_FOR_LEGAL_REASONS: Object.freeze({
+        status: 451,
+        statusText: "Unavailable For Legal Reasons"
+    })
+});
+
+export type TClientErrorStatuses =
+    (typeof clientErrorStatuses)[keyof typeof clientErrorStatuses]["status"];
+//#endregion
+
+//#region [Server error]
+export const serverErrorStatuses = Object.freeze({
+    INTERNAL_SERVER_ERROR: Object.freeze({
+        status: 500,
+        statusText: "Internal Server Error"
+    }),
+    NOT_IMPLEMENTED: Object.freeze({
+        status: 501,
+        statusText: "Not Implemented"
+    }),
+    BAD_GATEWAY: Object.freeze({
+        status: 502,
+        statusText: "Bad Gateway"
+    }),
+    SERVICE_UNAVAILABLE: Object.freeze({
+        status: 503,
+        statusText: "Service Unavailable"
+    }),
+    GATEWAY_TIMEOUT: Object.freeze({
+        status: 504,
+        statusText: "Gateway Timeout"
+    }),
+    HTTP_VERSION_NOT_SUPPORTED: Object.freeze({
+        status: 505,
+        statusText: "HTTP Version Not Supported"
+    }),
+    VARIANT_ALSO_NEGOTIATES: Object.freeze({
+        status: 506,
+        statusText: "Variant Also Negotiates"
+    }),
+    INSUFFICIENT_STORAGE: Object.freeze({
+        status: 507,
+        statusText: "Insufficient Storage"
+    }),
+    LOOP_DETECTED: Object.freeze({
+        status: 508,
+        statusText: "Loop Detected"
+    }),
+    NOT_EXTENDED: Object.freeze({
+        status: 510,
+        statusText: "Not Extended"
+    }),
+    NETWORK_AUTHENTICATION_REQUIRED: Object.freeze({
+        status: 511,
+        statusText: "Network Authentication Required"
+    })
+});
+
+export type TServerErrorStatuses =
+    (typeof serverErrorStatuses)[keyof typeof serverErrorStatuses]["status"];
+//#endregion
+
+export const httpStatuses = Object.freeze({
+    ...informationalStatuses,
+    ...successfulStatuses,
+    ...redirectionStatuses,
+    ...clientErrorStatuses,
+    ...serverErrorStatuses
+});

package/src/decorators/arguments.ts

@@ -11,7 +11,7 @@ import {
     requestHeadersArgsKey,
     responseHeadersArgsKey,
     routeModelArgsKey
-} from "../keys";
+} from "../constants/keys";
 
 export type TArgumentsMetadata<TValidationSchema = unknown> =
     | {
@@ -50,7 +50,6 @@ export type TArgumentsMetadata<TValidationSchema = unknown> =
     | {
           index: number;
           type: typeof requestArgsKey;
-          validationSchema?: TValidationSchema;
       }
     | {
           index: number;
@@ -229,7 +228,7 @@ export const Query =
     };
 
 export const Request =
-    <TTarget extends Object, TValidationSchema = unknown>(validationSchema?: TValidationSchema) =>
+    <TTarget extends Object, TValidationSchema = unknown>() =>
     (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => {
         if (!methodName) {
             return;
@@ -240,8 +239,7 @@ export const Request =
 
         metadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: requestArgsKey,
-            validationSchema: validationSchema
+            type: requestArgsKey
         } satisfies Extract<
             TArgumentsMetadata,
             {

package/src/decorators/container.ts

@@ -1,6 +1,14 @@
-import type { TConstructor } from "../ultils";
+import type { TConstructor } from "../utils";
+import type { TModuleMetadata } from "./module";
 
-import { containerKey, guardKey, injectableKey, middlewareKey, moduleKey } from "../keys";
+import {
+    containerKey,
+    guardKey,
+    injectableKey,
+    interceptorKey,
+    middlewareKey,
+    moduleKey
+} from "../constants/keys";
 
 type TLoaders<TConfig extends {} = {}> = Record<
     string | symbol,
@@ -16,23 +24,27 @@ export type TContainerConfig<TConfig> =
 
 export type TContainerOptions<TConfig extends {} = {}> =
     | Partial<{
+          prefix: string;
           loaders: TLoaders<TConfig>;
           config: TContainerConfig<TConfig>;
           modules: Array<TConstructor<unknown>>;
           dependencies: Array<TConstructor<unknown>>;
           middlewares: Array<TConstructor<unknown>>;
           guards: Array<TConstructor<unknown>>;
+          interceptors: Array<TConstructor<unknown>>;
       }>
     | undefined;
 
 export type TContainerMetadata<TConfig extends {} = {}> =
     | Partial<{
+          prefix: string;
           loaders: TLoaders<TConfig>;
           config: TContainerConfig<TConfig>;
           modules: Array<TConstructor<unknown>>;
           dependencies: Array<TConstructor<unknown>>;
           middlewares: Array<TConstructor<unknown>>;
           guards: Array<TConstructor<unknown>>;
+          interceptors: Array<TConstructor<unknown>>;
       }>
     | undefined;
 
@@ -41,7 +53,7 @@ export const Container =
         args?: TContainerOptions<TConfig>
     ) =>
     (target: K) => {
-        const { modules, middlewares, guards, dependencies } = args || {};
+        const { modules, middlewares, guards, interceptors, dependencies } = args || {};
 
         if (Reflect.hasOwnMetadata(moduleKey, target)) {
             throw new Error(
@@ -50,41 +62,49 @@ export const Container =
         }
 
         if (modules) {
-            for (let i = 0; i < modules.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(modules[i]).includes(moduleKey)) {
-                    throw Error(`${modules[i].name} is not a module.`);
+            const modulePrefixes: string[] = [];
+
+            for (const module of modules) {
+                if (!Reflect.getOwnMetadataKeys(module).includes(moduleKey)) {
+                    throw Error(`[${module.name}] is not a module.`);
+                }
+
+                const moduleMetadata: TModuleMetadata = Reflect.getOwnMetadata(moduleKey, module);
+
+                if (modulePrefixes.includes(moduleMetadata?.prefix || "")) {
+                    throw new Error(`Duplicated prefix of module [${module.name}].`);
                 }
             }
         }
 
         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.`);
+            for (const middleware of middlewares) {
+                if (!Reflect.getOwnMetadataKeys(middleware).includes(middlewareKey)) {
+                    throw Error(`[${middleware.name}] is not a middleware.`);
                 }
             }
         }
 
-        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 (const guard of guards) {
+                if (!Reflect.getOwnMetadataKeys(guard).includes(guardKey)) {
+                    throw Error(`[${guard.name}] is not a guard.`);
                 }
             }
         }
 
-        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 (interceptors) {
+            for (const interceptor of interceptors) {
+                if (!Reflect.getOwnMetadataKeys(interceptor).includes(interceptorKey)) {
+                    throw Error(`${interceptor.name} is not a middleware.`);
                 }
             }
         }
 
         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.`);
+            for (const dependency of dependencies) {
+                if (!Reflect.getOwnMetadataKeys(dependency).includes(injectableKey)) {
+                    throw Error(`${dependency.name} is not an injectable.`);
                 }
             }
         }

package/src/decorators/controller.ts

@@ -1,7 +1,7 @@
-import type { TConstructor } from "../ultils";
+import type { TConstructor } from "../utils";
 import type { THttpMetadata } from "./http";
 
-import { controllerHttpKey, controllerKey } from "../keys";
+import { controllerHttpKey, controllerKey } from "../constants/keys";
 
 export type TControllerMetadata = Required<{
     prefix: string;