@bool-ts/core 1.9.28 → 2.0.0

package/dist/decorators/arguments.d.ts

@@ -1,36 +1,35 @@
-import * as Zod from "zod";
 import { contextArgsKey, httpServerArgsKey, paramArgsKey, paramsArgsKey, queryArgsKey, requestArgsKey, requestBodyArgsKey, requestHeaderArgsKey, requestHeadersArgsKey, responseHeadersArgsKey, routeModelArgsKey } from "../keys";
-export type TArgumentsMetadata = {
+export type TArgumentsMetadata<TValidationSchema = unknown> = {
     index: number;
     type: typeof requestHeadersArgsKey;
-    zodSchema?: Zod.Schema;
+    validationSchema?: TValidationSchema;
 } | {
     index: number;
     type: typeof requestHeaderArgsKey;
     key: string;
-    zodSchema?: Zod.Schema;
+    validationSchema?: TValidationSchema;
 } | {
     index: number;
     type: typeof requestBodyArgsKey;
-    zodSchema?: Zod.Schema;
+    validationSchema?: TValidationSchema;
     parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text";
 } | {
     index: number;
     type: typeof paramsArgsKey;
-    zodSchema?: Zod.Schema;
+    validationSchema?: TValidationSchema;
 } | {
     index: number;
     type: typeof paramArgsKey;
     key: string;
-    zodSchema?: Zod.Schema;
+    validationSchema?: TValidationSchema;
 } | {
     index: number;
     type: typeof queryArgsKey;
-    zodSchema?: Zod.Schema;
+    validationSchema?: TValidationSchema;
 } | {
     index: number;
     type: typeof requestArgsKey;
-    zodSchema?: Zod.Schema;
+    validationSchema?: TValidationSchema;
 } | {
     index: number;
     type: typeof responseHeadersArgsKey;
@@ -46,14 +45,14 @@ export type TArgumentsMetadata = {
     type: typeof httpServerArgsKey;
 };
 export type TArgumentsMetadataCollection = Record<`argumentIndexes.${number}`, TArgumentsMetadata>;
-export declare const RequestHeaders: <T extends Object>(schema?: Zod.Schema) => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const RequestHeader: <T extends Object>(key: string, schema?: Zod.Schema) => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const RequestBody: <T extends Object>(schema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const Params: <T extends Object>(schema?: Zod.Schema) => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const Param: <T extends Object>(key: string, schema?: Zod.Schema) => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const Query: <T extends Object>(schema?: Zod.Schema) => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const Request: <T extends Object>(schema?: Zod.Schema) => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const ResponseHeaders: <T extends Object>() => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const Context: <T extends Object>(key?: symbol) => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const RouteModel: <T extends Object>() => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
-export declare const HttpServer: <T extends Object>() => (target: T, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const RequestHeaders: <TTarget extends Object, TValidationSchema = unknown>(validationSchema?: TValidationSchema) => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const RequestHeader: <TTarget extends Object, TValidationSchema = unknown>(key: string, validationSchema?: TValidationSchema) => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const RequestBody: <TTarget extends Object, TValidationSchema = unknown>(validationSchema?: TValidationSchema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Params: <TTarget extends Object, TValidationSchema = unknown>(validationSchema?: TValidationSchema) => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Param: <TTarget extends Object, TValidationSchema = unknown>(key: string, validationSchema?: TValidationSchema) => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Query: <TTarget extends Object, TValidationSchema = unknown>(validationSchema?: TValidationSchema) => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Request: <TTarget extends Object, TValidationSchema = unknown>(validationSchema?: TValidationSchema) => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const ResponseHeaders: <TTarget extends Object>() => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Context: <TTarget extends Object>(key?: symbol) => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const RouteModel: <TTarget extends Object>() => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const HttpServer: <TTarget extends Object>() => (target: TTarget, methodName: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/container.d.ts

@@ -1,5 +1,4 @@
 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]>>;
@@ -8,20 +7,20 @@ export type TContainerConfig<TConfig> = TConfig | (() => TConfig | Promise<TConf
     value: TConfig | (() => TConfig | Promise<TConfig>);
 }>;
 export type TContainerOptions<TConfig extends {} = {}> = Partial<{
-    config: TContainerConfig<TConfig>;
-    modules: TInstances;
-    dependencies: TInstances;
     loaders: TLoaders<TConfig>;
-    middlewares: TInstances;
-    guards: TInstances;
+    config: TContainerConfig<TConfig>;
+    modules: Array<TConstructor<unknown>>;
+    dependencies: Array<TConstructor<unknown>>;
+    middlewares: Array<TConstructor<unknown>>;
+    guards: Array<TConstructor<unknown>>;
 }> | undefined;
 export type TContainerMetadata<TConfig extends {} = {}> = Partial<{
-    modules: TInstances;
-    config: TContainerConfig<TConfig>;
-    dependencies: TInstances;
     loaders: TLoaders<TConfig>;
-    middlewares: TInstances;
-    guards: TInstances;
+    config: TContainerConfig<TConfig>;
+    modules: Array<TConstructor<unknown>>;
+    dependencies: Array<TConstructor<unknown>>;
+    middlewares: Array<TConstructor<unknown>>;
+    guards: Array<TConstructor<unknown>>;
 }> | undefined;
 export declare const Container: <TConfig extends {} = {}, K extends TConstructor<Object> = TConstructor<Object>>(args?: TContainerOptions<TConfig>) => (target: K) => void;
 export default Container;

package/dist/decorators/http.d.ts

@@ -12,42 +12,42 @@ export type THttpMetadata = Array<TRoute>;
  * @param path
  * @returns
  */
-export declare const Get: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
+export declare const Get: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
 /**
  *
  * @param path
  * @returns
  */
-export declare const Post: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
+export declare const Post: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
 /**
  *
  * @param path
  * @returns
  */
-export declare const Put: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
+export declare const Put: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
 /**
  *
  * @param path
  * @returns
  */
-export declare const Patch: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
+export declare const Patch: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
 /**
  *
  * @param path
  * @returns
  */
-export declare const Delete: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
+export declare const Delete: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
 /**
  *
  * @param path
  * @returns
  */
-export declare const Options: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
+export declare const Options: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
 declare const _default: {
-    Get: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
-    Post: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
-    Put: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
-    Patch: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
-    Delete: <T, K extends Object>(path?: string) => (target: K, methodName: string | symbol, descriptor: TypedPropertyDescriptor<T>) => void;
+    Get: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
+    Post: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
+    Put: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
+    Patch: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
+    Delete: <T extends Object, K>(path?: string) => (target: T, methodName: string | symbol, descriptor: TypedPropertyDescriptor<K>) => void;
 };
 export default _default;

package/dist/decorators/index.d.ts

@@ -11,8 +11,7 @@ export { Module } from "./module";
 export { WebSocket } from "./webSocket";
 export { WebSocketCloseCode, WebSocketCloseReason, WebSocketConnection, WebSocketMessage, WebSocketServer } from "./webSocketArguments";
 export { WebSocketEvent } from "./webSocketEvent";
-export { ZodSchema } from "./zodSchema";
-export type { TArgumentsMetadata } from "./arguments";
+export type { TArgumentsMetadata, TArgumentsMetadataCollection } from "./arguments";
 export type { TContainerConfig, TContainerMetadata, TContainerOptions } from "./container";
 export type { TControllerMetadata } from "./controller";
 export type { TGuardMetadata } from "./guard";

package/dist/entities/application.d.ts

@@ -0,0 +1,111 @@
+import type { TContainerMetadata, TWebSocketEventHandlerMetadata } from "../decorators";
+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<{
+    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">;
+    }>;
+    queryParser: Parameters<typeof QsParse>[1];
+    static: Required<{
+        path: string;
+    }> & Partial<{
+        headers: TParamsType;
+        cacheTimeInSeconds: number;
+    }>;
+    cors: Partial<{
+        credentials: boolean;
+        origins: string | Array<string>;
+        methods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
+        headers: Array<string>;
+    }>;
+}>;
+type TPreLaunch = undefined | Readonly<{
+    containerMetadata: TContainerMetadata;
+    modulesConverted: Array<TConstructor<unknown>>;
+    resolutedContainer?: Awaited<ReturnType<Application["containerResolution"]>>;
+    resolutedModules: Array<Awaited<ReturnType<Application["moduleResolution"]>>>;
+    webSocketsMap: Map<string, TWebSocketEventHandlerMetadata>;
+}>;
+export declare class Application<TRootClass extends Object = Object> {
+    #private;
+    private readonly classConstructor;
+    private readonly options;
+    constructor(classConstructor: TConstructor<TRootClass>, options: TApplicationOptions);
+    useValidator(validator: ICustomValidator): void;
+    /**
+     *
+     * @returns
+     */
+    preLaunch(): Promise<NonNullable<TPreLaunch>>;
+    /**
+     * Start listen app on a port
+     * @param port
+     */
+    listen(): Promise<void>;
+    /**
+     *
+     * @param param0
+     * @returns
+     */
+    private containerResolution;
+    /**
+     *
+     * @param param0
+     * @returns
+     */
+    private moduleResolution;
+    /**
+     *
+     * @param data
+     * @param zodSchema
+     * @param argumentIndex
+     * @param funcName
+     * @returns
+     */
+    private argumentsResolution;
+    /**
+     *
+     * @param param0
+     * @returns
+     */
+    private initControllerInstance;
+    /**
+     *
+     * @param param0
+     * @returns
+     */
+    private initWebSocketInstance;
+    /**
+     *
+     * @param param0
+     * @returns
+     */
+    private serializeResponse;
+    /**
+     *
+     * @param response
+     * @returns
+     */
+    private finalizeResponse;
+    /**
+     *
+     * @param param0
+     * @returns
+     */
+    private httpFetcher;
+    /**
+     *
+     * @param bun
+     * @param bool
+     * @returns
+     */
+    private webSocketFetcher;
+}
+export {};

package/dist/entities/context.d.ts

@@ -0,0 +1,14 @@
+import type { IContext, TContextOptions } from "../interfaces";
+export declare class Context implements IContext {
+    private readonly _staticMap;
+    private readonly _dynamicMap;
+    private _options?;
+    constructor(...contexts: Array<Context>);
+    get<T = unknown>(key: symbol, options?: TContextOptions): T;
+    has(key: symbol, options?: TContextOptions): boolean;
+    set(key: symbol, value: any, options?: TContextOptions): this;
+    setOptions(options: TContextOptions): this;
+    get staticEntries(): [symbol, any][];
+    get dynamicEntries(): [symbol, any][];
+}
+export default Context;

package/dist/entities/httpRoute.d.ts

@@ -12,41 +12,50 @@ export declare class HttpRoute {
     readonly alias: string;
     private _map;
     constructor(alias: string);
+    /**
+     *
+     * @param pathname
+     * @param method
+     * @returns
+     */
     test(pathname: string, method: keyof THttpMethods): Readonly<{
         parameters: Record<string, string>;
         model: THttpRouteModel;
     }> | false | undefined;
     /**
      *
+     * @param pathname
+     * @param method
+     * @returns
      */
     isMatch(pathname: string, method: keyof THttpMethods): boolean | undefined;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     get(handler: THttpRouteModel): this;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     post(handler: THttpRouteModel): this;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     put(handler: THttpRouteModel): this;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     delete(handler: THttpRouteModel): this;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     connect(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
@@ -57,7 +66,7 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     options(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
@@ -68,7 +77,7 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     trace(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
@@ -79,7 +88,7 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     patch(handler: THttpRouteModel): this | Map<keyof THttpMethods, Readonly<{
@@ -90,7 +99,7 @@ export declare class HttpRoute {
     }>>;
     /**
      *
-     * @param handlers
+     * @param handler
      * @returns
      */
     private _thinAlias;

package/dist/entities/httpRouter.d.ts

@@ -3,8 +3,21 @@ export declare class HttpRouter {
     readonly alias: string;
     private _routes;
     constructor(alias: string);
+    /**
+     *
+     * @param alias
+     * @returns
+     */
     route(alias: string): HttpRoute;
+    /**
+     *
+     * @param alias
+     * @returns
+     */
     private _thinAlias;
+    /**
+     *
+     */
     get routes(): Map<string, HttpRoute>;
 }
 export default HttpRouter;

package/dist/entities/httpRouterGroup.d.ts

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

package/dist/entities/index.d.ts

@@ -1,7 +1,9 @@
 export type { THttpRouteModel } from "./httpRoute";
+export { Application } from "./application";
 export { HttpRoute } from "./httpRoute";
 export { HttpRouter } from "./httpRouter";
 export { HttpRouterGroup } from "./httpRouterGroup";
+export { ValidationFailed } from "./validationFailed";
 export { WebSocketRoute } from "./webSocketRoute";
 export { WebSocketRouter } from "./webSocketRouter";
 export { WebSocketRouterGroup } from "./webSocketRouterGroup";

package/dist/entities/injector.d.ts

@@ -0,0 +1,29 @@
+import "reflect-metadata";
+type TDefinition<T = any> = {
+    new (...args: any[]): T;
+} | string | symbol;
+interface IInjector {
+    set(key: TDefinition, value: any): void;
+    get<T>(definition: TDefinition): T;
+}
+export declare class Injector implements IInjector {
+    private readonly _mapper;
+    /**
+     *
+     * @param injectors
+     */
+    constructor(...injectors: Array<Injector>);
+    /**
+     *
+     * @param definition
+     */
+    get<T>(definition: TDefinition): any;
+    /**
+     *
+     * @param key
+     * @param value
+     */
+    set(key: TDefinition, value: any): void;
+    get entries(): [string | symbol | Function, any][];
+}
+export default Injector;

package/dist/entities/validationFailed.d.ts

@@ -0,0 +1,5 @@
+export declare class ValidationFailed {
+    readonly error?: unknown | undefined;
+    constructor(error?: unknown | undefined);
+}
+export default ValidationFailed;

package/dist/entities/webSocketRoute.d.ts

@@ -10,3 +10,4 @@ export declare class WebSocketRoute {
     bind(instance: Object): ThisType<WebSocketRoute>;
     execute(): Readonly<TWebSocketEventHandlerMetadata>;
 }
+export default WebSocketRoute;

package/dist/entities/webSocketRouter.d.ts

@@ -29,3 +29,4 @@ export declare class WebSocketRouter {
      */
     static thinAlias(alias: string): string;
 }
+export default WebSocketRouter;

package/dist/entities/webSocketRouterGroup.d.ts

@@ -23,3 +23,4 @@ export declare class WebSocketRouterGroup {
      */
     static thinPrefix(prefix: string): string;
 }
+export default WebSocketRouterGroup;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import "reflect-metadata";
 export type { THttpRouteModel } from "./entities";
 export * from "./decorators";
+export * from "./entities";
 export * from "./http";
 export * from "./interfaces";
 export * as Keys from "./keys";