@bool-ts/core 2.1.2 → 2.2.0

package/README.md

@@ -26,7 +26,7 @@ bun add @bool-ts/core
 
 ## Documentation
 
-For detailed documentation, please visit [https://boolts.dev](https://boolts.dev)
+For detailed documentation, please visit [https://www.booljs.com](https://www.booljs.com)
 
 ## Quick Start
 

package/dist/decorators/container.d.ts

@@ -1,7 +1,7 @@
 import type { TConstructor } from "../ultils";
 type TLoaders<TConfig extends {} = {}> = Record<string | symbol, (args: {
     config: TConfig;
-}) => [string | symbol, any] | Promise<[string | symbol, any]>>;
+}) => [string | symbol, unknown] | Promise<[string | symbol, unknown]>>;
 export type TContainerConfig<TConfig> = TConfig | (() => TConfig | Promise<TConfig>) | Readonly<{
     key: symbol;
     value: TConfig | (() => TConfig | Promise<TConfig>);

package/dist/decorators/module.d.ts

@@ -2,7 +2,7 @@ import type { TConstructor } from "../ultils";
 type TInstances = Array<new (...args: any[]) => any>;
 type TLoaders<TConfig extends {} = {}> = Record<string | symbol, (args: {
     config: TConfig;
-}) => [string | symbol, any] | Promise<[string | symbol, any]>>;
+}) => [string | symbol, unknown] | Promise<[string | symbol, unknown]>>;
 export type TModuleConfig<TConfig> = TConfig | (() => TConfig | Promise<TConfig>) | Readonly<{
     key: symbol;
     value: TConfig | (() => TConfig | Promise<TConfig>);

package/dist/entities/application.d.ts

@@ -1,16 +1,17 @@
 import type { TContainerMetadata, TWebSocketEventHandlerMetadata } from "../decorators";
+import type { THttpMethods } from "../http";
+import type { ICustomValidator } from "../interfaces/customValidator";
 import type { TConstructor } from "../ultils";
 import { parse as QsParse } from "qs";
-import type { ICustomValidator } from "../interfaces/customValidator";
 type TParamsType = Record<string, string>;
-type TApplicationOptions = Required<{
+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: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
+        methods: AllowedMethods;
     }>;
     queryParser: Parameters<typeof QsParse>[1];
     static: Required<{
@@ -22,7 +23,7 @@ type TApplicationOptions = Required<{
     cors: Partial<{
         credentials: boolean;
         origins: string | Array<string>;
-        methods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
+        methods: Array<THttpMethods>;
         headers: Array<string>;
     }>;
 }>;

package/dist/entities/httpRoute.d.ts

@@ -7,58 +7,69 @@ export type THttpRouteModel<T = unknown> = Readonly<{
     argumentsMetadata: TArgumentsMetadataCollection;
 }>;
 export declare class HttpRoute {
+    #private;
     static rootPattern: string;
     static innerRootPattern: string;
     readonly alias: string;
-    private _map;
-    constructor(alias: string);
+    constructor({ alias }: {
+        alias: string;
+    });
     /**
      *
      * @param pathname
      * @param method
      * @returns
      */
-    test(pathname: string, method: keyof THttpMethods): Readonly<{
-        parameters: Record<string, string>;
+    test({ pathname }: {
+        pathname: string;
+    }): boolean;
+    exec({ pathname, method }: {
+        pathname: string;
+        method: THttpMethods;
+    }): Readonly<{
+        parameters: Record<string, string | undefined>;
         model: THttpRouteModel;
-    }> | false | undefined;
+    }> | null;
     /**
      *
-     * @param pathname
-     * @param method
+     * @param model
      * @returns
      */
-    isMatch(pathname: string, method: keyof THttpMethods): boolean | undefined;
-    /**
-     *
-     * @param handler
-     * @returns
-     */
-    get(handler: THttpRouteModel): this;
+    get({ model }: {
+        model: THttpRouteModel;
+    }): this;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    post(handler: THttpRouteModel): this;
+    post({ model }: {
+        model: THttpRouteModel;
+    }): this;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    put(handler: THttpRouteModel): this;
+    put({ model }: {
+        model: THttpRouteModel;
+    }): this;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    delete(handler: THttpRouteModel): this;
+    delete({ model }: {
+        model: THttpRouteModel;
+    }): this;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    connect(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    connect({ model }: {
+        model: THttpRouteModel;
+    }): this | Map<THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -66,10 +77,12 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    options(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    options({ model }: {
+        model: THttpRouteModel;
+    }): this | Map<THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -77,10 +90,12 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    trace(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    trace({ model }: {
+        model: THttpRouteModel;
+    }): this | Map<THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -88,10 +103,12 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
-    patch(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
+    patch({ model }: {
+        model: THttpRouteModel;
+    }): this | Map<THttpMethods, Readonly<{
         class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
@@ -99,7 +116,7 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handler
+     * @param model
      * @returns
      */
     private _thinAlias;

package/dist/entities/httpRouter.d.ts

@@ -2,7 +2,9 @@ import HttpRoute from "./httpRoute";
 export declare class HttpRouter {
     readonly alias: string;
     private _routes;
-    constructor(alias: string);
+    constructor({ alias }: {
+        alias: string;
+    });
     /**
      *
      * @param alias

package/dist/entities/httpRouterGroup.d.ts

@@ -1,16 +1,20 @@
 import type { THttpMethods } from "../http";
+import type { THttpRouteModel } from "./httpRoute";
 import type { HttpRouter } from "./httpRouter";
 export declare class HttpRouterGroup {
     private _routers;
     add(...routers: Array<HttpRouter>): this;
     /**
      *
-     * @param pathame
+     * @param pathname
      * @param method
      * @returns
      */
-    find(pathame: string, method: keyof THttpMethods): Readonly<{
-        parameters: Record<string, string>;
-        model: import("./httpRoute").THttpRouteModel;
-    }> | undefined;
+    find({ pathname, method }: {
+        pathname: string;
+        method: THttpMethods;
+    }): Readonly<{
+        parameters: Record<string, string | undefined>;
+        model: THttpRouteModel;
+    }> | null;
 }

package/dist/http/clientError.d.ts

@@ -29,13 +29,13 @@ export declare const httpClientErrors: Readonly<{
     431: "REQUEST_HEADER_FIELDS_TOO_LARGE";
     451: "UNAVAILABLE_FOR_LEGAL_REASONS";
 }>;
-export declare class HttpClientError<T extends keyof typeof httpClientErrors = keyof typeof httpClientErrors, K = any> extends Error {
+export declare class HttpClientError<T extends keyof typeof httpClientErrors = keyof typeof httpClientErrors, K = unknown> extends Error {
     readonly httpCode: T;
     readonly message: (typeof httpClientErrors)[T] | string;
-    readonly data: K;
+    readonly data: K | undefined;
     constructor({ httpCode, data, message }: {
         httpCode: T;
-        data: K;
+        data?: K;
         message?: string;
     });
 }

package/dist/http/index.d.ts

@@ -1,14 +1,6 @@
-export type THttpMethods = {
-    GET: "GET";
-    HEAD: "HEAD";
-    POST: "POST";
-    PUT: "PUT";
-    DELETE: "DELETE";
-    CONNECT: "CONNECT";
-    OPTIONS: "OPTIONS";
-    TRACE: "TRACE";
-    PATCH: "PATCH";
-};
+export type THttpMethods = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE" | "PATCH";
+export declare const httpMethods: Array<THttpMethods>;
+export declare const httpMethodsStandardization: (method: string) => method is THttpMethods;
 export declare const jsonErrorInfer: (data: any, headers?: Headers) => Response;
 export * from "./clientError";
 export * from "./serverError";

package/dist/http/serverError.d.ts

@@ -14,10 +14,10 @@ export declare const httpServerErrors: Readonly<{
 export declare class HttpServerError<T extends keyof typeof httpServerErrors = keyof typeof httpServerErrors, K = any> extends Error {
     readonly httpCode: T;
     readonly message: (typeof httpServerErrors)[T] | string;
-    readonly data: K;
+    readonly data: K | undefined;
     constructor({ httpCode, data, message }: {
         httpCode: T;
-        data: K;
+        data?: K;
         message?: string;
     });
 }