@bool-ts/core 2.2.3 → 2.3.0

package/src/entities/context.ts

@@ -18,7 +18,10 @@ export class Context implements IContext {
     }
 
     get<T = unknown>(key: symbol, options?: TContextOptions) {
-        const temporaryOptions = options || this._options;
+        const temporaryOptions = {
+            ...this._options,
+            ...options
+        };
 
         return !temporaryOptions?.isStatic
             ? (this._dynamicMap.get(key) as T)
@@ -26,13 +29,19 @@ export class Context implements IContext {
     }
 
     has(key: symbol, options?: TContextOptions) {
-        const temporaryOptions = options || this._options;
+        const temporaryOptions = {
+            ...this._options,
+            ...options
+        };
 
         return !temporaryOptions?.isStatic ? this._dynamicMap.has(key) : this._staticMap.has(key);
     }
 
     set(key: symbol, value: any, options?: TContextOptions) {
-        const temporaryOptions = options || this._options;
+        const temporaryOptions = {
+            ...this._options,
+            ...options
+        };
 
         if (!temporaryOptions?.isStatic) {
             this._dynamicMap.set(key, value);

package/src/entities/httpRoute.ts

@@ -8,12 +8,9 @@ export type THttpRouteModel<T = unknown> = Readonly<{
     argumentsMetadata: TArgumentsMetadataCollection;
 }>;
 
-const BASE_URL = "http://www.booljs.com";
+const BASE_URL = "https://www.booljs.com";
 
 export class HttpRoute {
-    public static rootPattern = ":([a-z0-9A-Z_-]{1,})";
-    public static innerRootPattern = "([a-z0-9A-Z_-]{1,})";
-
     public readonly alias: string;
 
     #map = new Map<THttpMethods, THttpRouteModel>();

package/src/entities/httpRouter.ts

@@ -1,12 +1,34 @@
+import type {
+    TCloseInterceptorHandlers,
+    TGuardHandlers,
+    TOpenInterceptorHandlers
+} from "../interfaces";
+
 import HttpRoute from "./httpRoute";
 
 export class HttpRouter {
     public readonly alias: string;
 
-    private _routes: Map<string, HttpRoute> = new Map();
+    #routes: Map<string, HttpRoute> = new Map();
+    #guardHandlers: TGuardHandlers;
+    #openInterceptorHandlers: TOpenInterceptorHandlers;
+    #closeInterceptorHandlers: TCloseInterceptorHandlers;
 
-    constructor({ alias }: { alias: string }) {
+    constructor({
+        alias,
+        guardHandlers: guards = [],
+        openInterceptorHandlers = [],
+        closeInterceptorHandlers = []
+    }: {
+        alias: string;
+        guardHandlers?: TGuardHandlers;
+        openInterceptorHandlers?: TOpenInterceptorHandlers;
+        closeInterceptorHandlers?: TCloseInterceptorHandlers;
+    }) {
         this.alias = this._thinAlias(alias);
+        this.#guardHandlers = guards;
+        this.#openInterceptorHandlers = openInterceptorHandlers;
+        this.#closeInterceptorHandlers = closeInterceptorHandlers;
     }
 
     /**
@@ -14,13 +36,13 @@ export class HttpRouter {
      * @param alias
      * @returns
      */
-    public route(alias: string) {
+    public route({ alias }: { alias: string }) {
         const thinAlias = this._thinAlias(`${this.alias}/${alias}`);
-        const route = this._routes.get(thinAlias);
+        const route = this.#routes.get(thinAlias);
         const newRoute = !route ? new HttpRoute({ alias: `${this.alias}/${alias}` }) : route;
 
         if (!route) {
-            this._routes.set(thinAlias, newRoute);
+            this.#routes.set(thinAlias, newRoute);
         }
 
         return newRoute;
@@ -41,7 +63,15 @@ export class HttpRouter {
      *
      */
     get routes() {
-        return this._routes;
+        return this.#routes;
+    }
+
+    get pipes() {
+        return Object.freeze({
+            guardHandlers: [...this.#guardHandlers],
+            openInterceptorHandlers: [...this.#openInterceptorHandlers],
+            closeInterceptorHandlers: [...this.#closeInterceptorHandlers]
+        });
     }
 }
 

package/src/entities/httpRouterGroup.ts

@@ -1,17 +1,22 @@
 import type { THttpMethods } from "../http";
+import type {
+    TCloseInterceptorHandlers,
+    TGuardHandlers,
+    TOpenInterceptorHandlers
+} from "../interfaces";
 import type { THttpRouteModel } from "./httpRoute";
 import type { HttpRouter } from "./httpRouter";
 
 export class HttpRouterGroup {
-    private _routers: Map<string, HttpRouter> = new Map();
+    #routers: Map<string, HttpRouter> = new Map();
 
     public add(...routers: Array<HttpRouter>) {
         for (const router of routers) {
-            if (this._routers.has(router.alias)) {
+            if (this.#routers.has(router.alias)) {
                 continue;
             }
 
-            this._routers.set(router.alias, router);
+            this.#routers.set(router.alias, router);
         }
 
         return this;
@@ -26,8 +31,11 @@ export class HttpRouterGroup {
     public find({ pathname, method }: { pathname: string; method: THttpMethods }): Readonly<{
         parameters: Record<string, string | undefined>;
         model: THttpRouteModel;
+        guardHandlers: TGuardHandlers;
+        openInterceptorHandlers: TOpenInterceptorHandlers;
+        closeInterceptorHandlers: TCloseInterceptorHandlers;
     }> | null {
-        for (const router of this._routers.values()) {
+        for (const router of this.#routers.values()) {
             for (const route of router.routes.values()) {
                 const testResult = route.test({ pathname });
 
@@ -41,7 +49,10 @@ export class HttpRouterGroup {
                     continue;
                 }
 
-                return execResult;
+                return Object.freeze({
+                    ...execResult,
+                    ...router.pipes
+                });
             }
         }
 

package/src/entities/injector.ts

@@ -7,13 +7,13 @@ import {
     interceptorKey,
     middlewareKey,
     webSocketKey
-} from "../keys";
+} from "../constants/keys";
 
 type TDefinition<T = any> = { new (...args: any[]): T } | string | symbol;
 
 interface IInjector {
     set(key: TDefinition, value: any): void;
-    get<T>(definition: TDefinition): T;
+    get<T>(definition: TDefinition): T | undefined;
 }
 
 export class Injector implements IInjector {
@@ -68,7 +68,7 @@ export class Injector implements IInjector {
 
         this._mapper.set(definition, instance);
 
-        return instance;
+        return instance as T;
     }
 
     /**

package/src/http/clientError.ts

@@ -1,48 +1,25 @@
-export const httpClientErrors = Object.freeze({
-    400: "BAD_REQUEST",
-    401: "UNAUTHORIZED",
-    402: "PAYMENT_REQUIRED",
-    403: "FORBIDDEN",
-    404: "NOT_FOUND",
-    405: "METHOD_NOT_ALLOWED",
-    406: "NOT_ACCEPTABLE",
-    407: "PROXY_AUTHENCATION_REQUIRED",
-    408: "REQUEST_TIMEOUT",
-    409: "CONFLICT",
-    410: "GONE",
-    411: "LENGTH_REQUIRED",
-    412: "PRECONDITION_FAILED",
-    413: "PAYLOAD_TOO_LARGE",
-    414: "URI_TOO_LONG",
-    415: "UNSUPPORTED_MEDIA_TYPE",
-    416: "RANGE_NOT_SATISFIABLE",
-    417: "EXPECTATION_FAILED",
-    418: "IM_A_TEAPOT",
-    421: "MISDIRECTED_REQUEST",
-    422: "UNPROCESSABLE_ENTITY",
-    423: "LOCKED",
-    424: "FAILED_DEPENDENCY",
-    425: "TOO_EARLY_",
-    426: "UPGRAGE_REQUIRED",
-    428: "PRECONDITION_REQUIRED",
-    429: "TOO_MANY_REQUESTS",
-    431: "REQUEST_HEADER_FIELDS_TOO_LARGE",
-    451: "UNAVAILABLE_FOR_LEGAL_REASONS"
-});
+import type { TClientErrorStatuses } from "../constants";
 
-export class HttpClientError<
-    T extends keyof typeof httpClientErrors = keyof typeof httpClientErrors,
-    K = unknown
-> extends Error {
-    public readonly httpCode: T;
-    public readonly message: (typeof httpClientErrors)[T] | string;
+import { inferStatusText } from "../utils";
+
+export class HttpClientError<K = unknown> extends Error {
+    public readonly httpCode: TClientErrorStatuses;
+    public readonly message: string;
     public readonly data: K | undefined;
 
-    constructor({ httpCode, data, message }: { httpCode: T; data?: K; message?: string }) {
+    constructor({
+        httpCode,
+        data,
+        message
+    }: {
+        httpCode: TClientErrorStatuses;
+        data?: K;
+        message?: string;
+    }) {
         super();
 
         this.httpCode = httpCode;
-        this.message = !message?.trim() ? httpClientErrors[httpCode] : message.trim();
+        this.message = !message?.trim() ? inferStatusText(httpCode) : message.trim();
         this.data = data;
     }
 }

package/src/http/serverError.ts

@@ -1,30 +1,25 @@
-export const httpServerErrors = Object.freeze({
-    500: "INTERNAL_SERVER_ERROR",
-    501: "NOT_IMPLEMENTED",
-    502: "BAD_GATEWAY",
-    503: "SERVICE_UNAVAILABLE",
-    504: "GATEWAY_TIMEOUT",
-    505: "HTTP_VERSION_NOT_SUPPORTED",
-    506: "VARIANT_ALSO_NEGOTIATES",
-    507: "INSUFFICIENT_STORAGE",
-    508: "LOOP_DETECTED",
-    510: "NOT_EXTENDED",
-    511: "NETWORK_AUTHENTICATION_REQUIRED"
-});
+import type { TServerErrorStatuses } from "../constants";
 
-export class HttpServerError<
-    T extends keyof typeof httpServerErrors = keyof typeof httpServerErrors,
-    K = any
-> extends Error {
-    public readonly httpCode: T;
-    public readonly message: (typeof httpServerErrors)[T] | string;
-    public readonly data: K | undefined;
+import { inferStatusText } from "../utils";
 
-    constructor({ httpCode, data, message }: { httpCode: T; data?: K; message?: string }) {
+export class HttpServerError<T = any> extends Error {
+    public readonly httpCode: TServerErrorStatuses;
+    public readonly message: string;
+    public readonly data: T | undefined;
+
+    constructor({
+        httpCode,
+        data,
+        message
+    }: {
+        httpCode: TServerErrorStatuses;
+        data?: T;
+        message?: string;
+    }) {
         super();
 
         this.httpCode = httpCode;
-        this.message = !message?.trim() ? httpServerErrors[httpCode] : message.trim();
+        this.message = !message?.trim() ? inferStatusText(httpCode) : message.trim();
         this.data = data;
     }
 }

package/src/index.ts

@@ -1,10 +1,20 @@
 import "reflect-metadata";
 
 export type { THttpRouteModel } from "./entities";
+export type {
+    IContainer,
+    IContext,
+    IController,
+    ICustomValidator,
+    IGuard,
+    IInterceptor,
+    IMiddleware,
+    IModule,
+    IWebSocket
+} from "./interfaces";
 
+export * from "./constants";
 export * from "./decorators";
 export * from "./entities";
 export * from "./http";
-export * from "./interfaces";
-export * as Keys from "./keys";
 export * from "./producers";

package/src/interfaces/@types.ts

@@ -0,0 +1,171 @@
+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/src/interfaces/guard.ts

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

package/src/interfaces/index.ts

@@ -1,8 +1,31 @@
+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/src/producers/factory.ts

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

package/src/utils/constructor.ts

@@ -0,0 +1 @@
+export type TConstructor<T, K extends any[] = any[]> = new (...args: K) => T;

package/src/utils/functions.ts

@@ -0,0 +1,13 @@
+import { Objects } from "../constants";
+
+export const inferStatusText = (httpCode: number): string => {
+    for (const [_key, value] of Object.entries(Objects.httpStatuses)) {
+        if (value.status !== httpCode) {
+            continue;
+        }
+
+        return value.statusText;
+    }
+
+    return "Unknown error";
+};

package/src/{ultils → utils}/index.ts

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