@vercube/core 0.0.1 → 0.0.2-beta.1

package/dist/index.mjs

@@ -8,7 +8,7 @@ import { BaseLogger, Logger } from "@vercube/logger";
 import { loadConfig } from "c12";
 import { defu } from "defu";
 
-//#region node_modules/.pnpm/@oxc-project+runtime@0.63.0/node_modules/@oxc-project/runtime/src/helpers/esm/decorate.js
+//#region node_modules/.pnpm/@oxc-project+runtime@0.65.0/node_modules/@oxc-project/runtime/src/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -56,6 +56,9 @@ __decorate([Inject(Container)], PluginsRegistry.prototype, "gContainer", void 0)
 
 //#endregion
 //#region packages/core/src/Services/Hooks/HooksService.ts
+/**
+* This class is responsible for managing events.
+*/
 var HooksService = class {
 	fLastId = 0;
 	fHandlers = new Map();
@@ -171,6 +174,13 @@ var RouterAfterInitHook = class {};
 
 //#endregion
 //#region packages/core/src/Services/Router/Router.ts
+/**
+* Router service responsible for managing application routes
+* 
+* This class provides functionality to initialize the router,
+* register routes, and resolve incoming requests to their
+* appropriate handlers.
+*/
 var Router = class {
 	/**
 	* Service for triggering application hooks
@@ -220,12 +230,27 @@ __decorate([Inject(HooksService)], Router.prototype, "gHooksService", void 0);
 
 //#endregion
 //#region packages/core/src/Resolvers/RouterParam.ts
+/**
+* Resolves a router parameter from the event object
+* @param param - The parameter name to resolve from the router event
+* @param event - The router event object containing parameters
+* @returns The resolved parameter value if it exists, null otherwise
+* @example
+* ```typescript
+* const value = resolveRouterParam('id', routerEvent);
+* // Returns the 'id' parameter value from routerEvent.params or null
+* ```
+*/
 function resolveRouterParam(param, event) {
 	return event.params?.[param] ?? null;
 }
 
 //#endregion
 //#region packages/core/src/Errors/HttpError.ts
+/**
+* Represents an HTTP error.
+* @extends {Error}
+*/
 var HttpError = class HttpError extends Error {
 	/**
 	* The HTTP status code associated with the error.
@@ -248,6 +273,10 @@ var HttpError = class HttpError extends Error {
 
 //#endregion
 //#region packages/core/src/Errors/Http/BadRequestError.ts
+/**
+* Represents a Bad Request error (HTTP 400).
+* @extends {HttpError}
+*/
 var BadRequestError = class BadRequestError extends HttpError {
 	/**
 	* The name of the error.
@@ -268,6 +297,26 @@ var BadRequestError = class BadRequestError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Resolvers/Body.ts
+/**
+* Resolves and parses the request body from a RouterEvent.
+* 
+* @param {RouterTypes.RouterEvent} event - The router event containing the request to process
+* @returns {Promise<unknown>} A promise that resolves to:
+*   - The parsed JSON body if the request contains valid JSON
+*   - undefined if the request body is empty
+* @throws {BadRequestError} If the request body contains invalid JSON
+* 
+* @example
+* const body = await resolveRequestBody(event);
+* if (body) {
+*   // Process the parsed body
+* }
+* 
+* @remarks
+* - Currently only supports JSON content type
+* - Returns undefined for empty request bodies
+* - Throws BadRequestError for malformed JSON
+*/
 async function resolveRequestBody(event) {
 	const text = await event.request.text();
 	if (!text) return void 0;
@@ -280,10 +329,21 @@ async function resolveRequestBody(event) {
 
 //#endregion
 //#region packages/core/src/Resolvers/Query.ts
+/**
+* Resolves a single query parameter from the URL of a router event
+* @param name - The name of the query parameter to resolve
+* @param event - The router event containing the request URL
+* @returns The value of the query parameter if found, null otherwise
+*/
 function resolveQueryParam(name, event) {
 	const url = new URL(event.request.url);
 	return url.searchParams.get(name);
 }
+/**
+* Resolves all query parameters from the URL of a router event
+* @param event - The router event containing the request URL
+* @returns An object containing all query parameters as key-value pairs
+*/
 function resolveQueryParams(event) {
 	const url = new URL(event.request.url);
 	const params = {};
@@ -293,15 +353,29 @@ function resolveQueryParams(event) {
 
 //#endregion
 //#region packages/core/src/Resolvers/Headers.ts
+/**
+* Retrieves a specific header value from the request
+* @param {string} header - The name of the header to retrieve
+* @param {RouterTypes.RouterEvent} event - The router event containing the request
+* @returns {string | null} The header value if found, null otherwise
+*/
 function getRequestHeader(header, event) {
 	return event.request.headers.get(header);
 }
+/**
+* Retrieves all headers from the request
+* @param {RouterTypes.RouterEvent} event - The router event containing the request
+* @returns {Headers} The complete Headers object from the request
+*/
 function getRequestHeaders(event) {
 	return event.request.headers;
 }
 
 //#endregion
 //#region packages/core/src/Services/Metadata/MetadataResolver.ts
+/**
+* Class responsible for resolving metadata for route handlers.
+*/
 var MetadataResolver = class {
 	/**
 	* Resolves the URL for a given instance and path.
@@ -377,10 +451,24 @@ var MetadataResolver = class {
 
 //#endregion
 //#region packages/core/src/Services/ErrorHandler/ErrorHandlerProvider.ts
+/**
+* Abstract class representing an error handler provider
+* Provides a common interface for different error handler implementations
+*
+* @abstract
+* @class ErrorHandlerProvider
+*/
 var ErrorHandlerProvider = class {};
 
 //#endregion
 //#region packages/core/src/Services/Middleware/GlobalMiddlewareRegistry.ts
+/**
+* Manages global middleware registration and retrieval
+* 
+* This class provides functionality to register and retrieve global middleware
+* configurations. It allows for adding middleware with specific options and
+* retrieving them in a standardized format.
+*/
 var GlobalMiddlewareRegistry = class {
 	fMiddlewares = new Set();
 	/**
@@ -412,13 +500,20 @@ var GlobalMiddlewareRegistry = class {
 
 //#endregion
 //#region packages/core/src/Services/Router/RequestHandler.ts
+/**
+* Handles HTTP requests by preparing and executing route handlers with their associated middlewares
+* 
+* The RequestHandler is responsible for:
+* - Preparing route handlers with their metadata
+* - Executing middleware chains (before and after)
+* - Processing request/response lifecycle
+* - Error handling during request processing
+*/
 var RequestHandler = class {
 	/** Resolver for extracting metadata from controller classes and methods */
 	gMetadataResolver;
 	/** DI container for resolving dependencies */
 	gContainer;
-	/** Provider for handling errors during request processing */
-	gErrorHandlerProvider;
 	gGlobalMiddlewareRegistry;
 	/**
 	* Prepares a route handler by resolving its metadata and middlewares
@@ -477,8 +572,8 @@ var RequestHandler = class {
 					methodArgs: args
 				});
 				if (hookResponse instanceof Response) return hookResponse;
-			} catch (error) {
-				return this.gErrorHandlerProvider.handleError(error);
+			} catch (error_) {
+				this.gContainer.get(ErrorHandlerProvider).handleError(error_);
 			}
 			for (const action of actions) {
 				const actionResponse = action.handler(request, fakeResponse);
@@ -494,8 +589,8 @@ var RequestHandler = class {
 			for await (const hook of middlewares?.afterMiddlewares ?? []) try {
 				const hookResponse = await hook.middleware.onResponse?.(request, fakeResponse, handlerResponse);
 				if (hookResponse !== null) fakeResponse = this.processOverrideResponse(hookResponse, fakeResponse);
-			} catch (error) {
-				return this.gErrorHandlerProvider.handleError(error);
+			} catch (error_) {
+				this.gContainer.get(ErrorHandlerProvider).handleError(error_);
 			}
 			const body = fakeResponse?.body ?? JSON.stringify(handlerResponse);
 			return new Response(body, {
@@ -504,7 +599,7 @@ var RequestHandler = class {
 				headers: fakeResponse.headers
 			});
 		} catch (error_) {
-			return this.gErrorHandlerProvider.handleError(error_);
+			return this.gContainer.get(ErrorHandlerProvider).handleError(error_);
 		}
 	}
 	/**
@@ -535,7 +630,6 @@ var RequestHandler = class {
 };
 __decorate([Inject(MetadataResolver)], RequestHandler.prototype, "gMetadataResolver", void 0);
 __decorate([Inject(Container)], RequestHandler.prototype, "gContainer", void 0);
-__decorate([Inject(ErrorHandlerProvider)], RequestHandler.prototype, "gErrorHandlerProvider", void 0);
 __decorate([Inject(GlobalMiddlewareRegistry)], RequestHandler.prototype, "gGlobalMiddlewareRegistry", void 0);
 
 //#endregion
@@ -558,6 +652,15 @@ const mime = { getType(ext) {
 
 //#endregion
 //#region packages/core/src/Services/Router/StaticRequestHandler.ts
+/**
+* Handles serving static files over HTTP
+* 
+* The StaticRequestHandler is responsible for:
+* - Serving static files from configured directories
+* - Setting appropriate content types and headers
+* - Handling caching and ETags
+* - Processing GET requests for static assets
+*/
 var StaticRequestHandler = class {
 	/**
 	* The options for the static server
@@ -623,7 +726,19 @@ var StaticRequestHandler = class {
 
 //#endregion
 //#region packages/core/src/Services/HttpServer/HttpServer.ts
+/**
+* HTTP server implementation for handling incoming web requests
+* 
+* This class is responsible for:
+* - Initializing and managing the HTTP server
+* - Routing incoming requests to appropriate handlers
+* - Processing HTTP responses
+*/
 var HttpServer = class {
+	/**
+	* DI container for resolving dependencies
+	*/
+	gContainer;
 	/**
 	* Router service for resolving routes
 	*/
@@ -633,10 +748,6 @@ var HttpServer = class {
 	*/
 	gRequestHandler;
 	/**
-	* Error handler provider for managing error responses
-	*/
-	gErrorHandlerProvider;
-	/**
 	* Static server for serving static files
 	*/
 	gStaticRequestHandler;
@@ -654,10 +765,10 @@ var HttpServer = class {
 		const { port, host } = config.server ?? {};
 		this.fServer = serve({
 			bun: { error: (error) => {
-				return this.gErrorHandlerProvider.handleError(error);
+				return this.gContainer.get(ErrorHandlerProvider).handleError(error);
 			} },
 			deno: { onError: (error) => {
-				return this.gErrorHandlerProvider.handleError(error);
+				return this.gContainer.get(ErrorHandlerProvider).handleError(error);
 			} },
 			hostname: host,
 			port,
@@ -697,17 +808,20 @@ var HttpServer = class {
 			}
 			return this.gRequestHandler.handleRequest(request, route);
 		} catch (error) {
-			return this.gErrorHandlerProvider.handleError(error);
+			return this.gContainer.get(ErrorHandlerProvider).handleError(error);
 		}
 	}
 };
+__decorate([Inject(Container)], HttpServer.prototype, "gContainer", void 0);
 __decorate([Inject(Router)], HttpServer.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], HttpServer.prototype, "gRequestHandler", void 0);
-__decorate([Inject(ErrorHandlerProvider)], HttpServer.prototype, "gErrorHandlerProvider", void 0);
 __decorate([Inject(StaticRequestHandler)], HttpServer.prototype, "gStaticRequestHandler", void 0);
 
 //#endregion
 //#region packages/core/src/Common/App.ts
+/**
+* Represents the main application class.
+*/
 var App = class {
 	gRouter;
 	gPluginsRegistry;
@@ -784,6 +898,13 @@ __decorate([Inject(StaticRequestHandler)], App.prototype, "gStaticRequestHandler
 
 //#endregion
 //#region packages/logger/dist/Providers/index.mjs
+/**
+* Abstract base class for implementing log provider.
+* Providers are responsible for processing and outputting log messages to various destinations.
+* Each appender can be initialized with custom options and handles message processing according to its implementation.
+*
+* @template T - The type of options used to initialize the appender
+*/
 var LoggerProvider = class {};
 const isColorAllowed = () => !process.env.NO_COLOR;
 const colorIfAllowed = (colorFn) => {
@@ -806,6 +927,9 @@ const LOG_LEVEL_COLORS = {
 	warn: colors.yellow,
 	error: colors.red
 };
+/**
+* ConsoleProvider class for logging messages to the console.
+*/
 var ConsoleProvider = class extends LoggerProvider {
 	/**
 	* Initializes the appender with the provided options.
@@ -825,10 +949,23 @@ var ConsoleProvider = class extends LoggerProvider {
 
 //#endregion
 //#region packages/core/src/Services/Validation/ValidationProvider.ts
+/**
+* Abstract class representing a validation provider
+* Provides a common interface for different validation implementations
+* 
+* @abstract
+* @class ValidationProvider
+*/
 var ValidationProvider = class {};
 
 //#endregion
 //#region packages/core/src/Services/Validation/StandardSchemaValidationProvider.ts
+/**
+* StandardSchemaValidationProvider implements validation using StandardSchema schema validation
+* @see https://github.com/standard-schema/standard-schema
+* @class
+* @implements {ValidationProvider}
+*/
 var StandardSchemaValidationProvider = class {
 	/**
 	* Validates data against a schema
@@ -843,6 +980,10 @@ var StandardSchemaValidationProvider = class {
 
 //#endregion
 //#region packages/core/src/Services/Config/RuntimeConfig.ts
+/**
+* RuntimeConfig class manages the runtime configuration for the Vercube application.
+* This class provides a centralized way to access and modify runtime configuration settings.
+*/
 var RuntimeConfig = class {
 	/**
 	* Private field to store the runtime configuration object.
@@ -867,6 +1008,10 @@ var RuntimeConfig = class {
 
 //#endregion
 //#region packages/core/src/Errors/Http/InternalServerError.ts
+/**
+* Represents an Internal Server error (HTTP 500).
+* @extends {HttpError}
+*/
 var InternalServerError = class InternalServerError extends HttpError {
 	/**
 	* The name of the error.
@@ -886,26 +1031,36 @@ var InternalServerError = class InternalServerError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Services/ErrorHandler/DefaultErrorHandlerProvider.ts
+/**
+* Default error handler provider
+*
+* @class DefaultErrorHandlerProvider
+*/
 var DefaultErrorHandlerProvider = class extends ErrorHandlerProvider {
 	gLogger;
 	/**
 	* Handles an error that occurred during request processing
-	* 
+	*
 	* @param error - The Error object containing error details
 	* @returns Promise<Response> | Response - The response to be sent to the client
 	*/
 	handleError(error) {
-		const _internalError = new InternalServerError();
+		const _internalError = new InternalServerError(error?.message ?? "Internal server error");
 		const status = error?.status ?? 500;
 		if (error instanceof HttpError) return new Response(JSON.stringify({ ...error }, void 0, 2), { status });
 		this.gLogger.error(error);
-		return new Response(JSON.stringify({ ...error?.cause ?? _internalError.cause }, void 0, 2), { status });
+		return new Response(JSON.stringify({ ...error?.cause ?? _internalError }, void 0, 2), { status });
 	}
 };
 __decorate([Inject(Logger)], DefaultErrorHandlerProvider.prototype, "gLogger", void 0);
 
 //#endregion
 //#region packages/core/src/Common/Container.ts
+/**
+* Creates and configures a new dependency injection container for the application.
+*
+* @returns {Container} A configured dependency injection container.
+*/
 function createContainer(config) {
 	const container = new Container();
 	container.bindInstance(Container, container);
@@ -933,6 +1088,10 @@ function createContainer(config) {
 
 //#endregion
 //#region packages/core/src/Utils/InternalUtils.ts
+/**
+* Generate random hash
+* @returns string
+*/
 function generateRandomHash() {
 	const hashByPerformance = Math.floor(Date.now() * 1e3).toString(16);
 	const hashByMath = () => (Math.floor(Math.random() * 16777215) | 1048576).toString(16);
@@ -941,6 +1100,10 @@ function generateRandomHash() {
 
 //#endregion
 //#region packages/core/src/Config/DefaultConfig.ts
+/**
+* Default configuration for the Vercube application.
+* This configuration serves as the base settings and can be overridden by user configuration.
+*/
 const defaultConfig = {
 	logLevel: "debug",
 	production: false,
@@ -971,6 +1134,11 @@ const defaultConfig = {
 
 //#endregion
 //#region packages/core/src/Config/Loader.ts
+/**
+* Loads the configuration object for the application
+* @param {ConfigTypes.Config} overrides - The configuration object to load
+* @returns {ConfigTypes.Config} The loaded configuration object
+*/
 async function loadVercubeConfig(overrides) {
 	const config = await loadConfig({
 		name: "vercube",
@@ -984,6 +1152,11 @@ async function loadVercubeConfig(overrides) {
 
 //#endregion
 //#region packages/core/src/Common/CreateApp.ts
+/**
+* Creates and initializes an instance of the App.
+*
+* @returns {Promise<App>} A promise that resolves to an instance of the App.
+*/
 async function createApp(cfg) {
 	const config = await loadVercubeConfig(cfg);
 	const container = createContainer(config);
@@ -997,12 +1170,26 @@ async function createApp(cfg) {
 
 //#endregion
 //#region packages/core/src/Config/Config.ts
+/**
+* Defines a configuration object for the application
+* @param {ConfigTypes.Config} config - The configuration object to validate
+* @returns {ConfigTypes.Config} The validated configuration object
+*/
 function defineConfig(config) {
 	return config;
 }
 
 //#endregion
 //#region packages/core/src/Middleware/ValidationMiddleware.ts
+/**
+* Middleware for validating request data against a schema
+* @class ValidationMiddleware
+* @implements {BaseMiddleware}
+* @description Validates incoming request data against a provided schema
+* @example
+* const middleware = new ValidationMiddleware();
+* await middleware.use(event, { schema: myValidationSchema });
+*/
 var ValidationMiddleware = class {
 	gValidationProvider;
 	/**
@@ -1029,6 +1216,10 @@ __decorate([InjectOptional(ValidationProvider)], ValidationMiddleware.prototype,
 
 //#endregion
 //#region packages/core/src/Utils/Utils.ts
+/**
+* Creates a new metadata context.
+* @returns {MetadataTypes.Ctx} The new metadata context.
+*/
 function createMetadataCtx() {
 	return {
 		__controller: { path: "" },
@@ -1036,6 +1227,10 @@ function createMetadataCtx() {
 		__methods: {}
 	};
 }
+/**
+* Creates a new metadata method.
+* @returns {MetadataTypes.Method} The new metadata method.
+*/
 function createMetadataMethod() {
 	return {
 		req: null,
@@ -1045,10 +1240,19 @@ function createMetadataMethod() {
 		actions: []
 	};
 }
+/**
+* Initializes the metadata for a given target and property name.
+* @param {any} target - The target to initialize metadata for.
+* @param {string} propertyName - The name of the property to initialize metadata for.
+*/
 function initializeMetadataMethod(target, propertyName) {
 	if (!target.__metadata.__methods[propertyName]) target.__metadata.__methods[propertyName] = createMetadataMethod();
 	return target.__metadata.__methods[propertyName];
 }
+/**
+* Initializes the metadata for a given target.
+* @param {any} target - The target to initialize metadata for.
+*/
 function initializeMetadata(target) {
 	if (!target.__metadata) target.__metadata = createMetadataCtx();
 	if (!target.__metadata.__methods) target.__metadata.__methods = {};
@@ -1058,6 +1262,12 @@ function initializeMetadata(target) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Body.ts
+/**
+* @class BodyDecorator
+* @extends BaseDecorator<BodyDecoratorOptions>
+*
+* A decorator class that handles the metadata for HTTP request bodies.
+*/
 var BodyDecorator = class extends BaseDecorator {
 	/**
 	* @method created
@@ -1081,12 +1291,30 @@ var BodyDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* @function Body
+* @returns {Function} A decorator function that registers the BodyDecorator.
+*
+* This function creates and returns a decorator that can be used to annotate
+* a parameter in a method to indicate that it should be populated with the
+* body of an HTTP request. The decorator uses the BodyDecorator class to
+* handle the metadata associated with the parameter.
+*/
 function Body(options) {
 	return createDecorator(BodyDecorator, options);
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Connect.ts
+/**
+* A decorator class for handling HTTP CONNECT requests.
+*
+* This class extends the BaseDecorator and is used to register CONNECT routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<ConnectDecoratorOptions>}
+*/
 var ConnectDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1116,12 +1344,30 @@ var ConnectDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], ConnectDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], ConnectDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], ConnectDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a ConnectDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with CONNECT route information.
+*
+* @param {string} path - The path for the CONNECT route.
+* @return {Function} The decorator function.
+*/
 function Connect(path) {
 	return createDecorator(ConnectDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Controller.ts
+/**
+* A factory function for creating a Controller decorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a class with controller metadata, including the base path for the controller.
+*
+* @param {string} path - The base path for the controller.
+* @return {Function} The decorator function.
+*/
 function Controller(path) {
 	return function internalDecorator(target) {
 		const meta = initializeMetadata(target.prototype);
@@ -1134,6 +1380,15 @@ function Controller(path) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Delete.ts
+/**
+* A decorator class for handling HTTP DELETE requests.
+*
+* This class extends the BaseDecorator and is used to register DELETE routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<DeleteDecoratorOptions>}
+*/
 var DeleteDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1165,12 +1420,30 @@ var DeleteDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], DeleteDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], DeleteDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], DeleteDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a DeleteDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with DELETE route information.
+*
+* @param {string} path - The path for the DELETE route.
+* @return {Function} The decorator function.
+*/
 function Delete(path) {
 	return createDecorator(DeleteDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Get.ts
+/**
+* A decorator class for handling HTTP GET requests.
+*
+* This class extends the BaseDecorator and is used to register GET routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<GetDecoratorOptions>}
+*/
 var GetDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1202,12 +1475,30 @@ var GetDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], GetDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], GetDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], GetDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A decorator function for handling HTTP GET requests.
+*
+* This function creates an instance of the GetDecorator class and registers
+* the GET route with the specified path.
+*
+* @param {string} path - The path for the GET route.
+* @returns {Function} - The decorator function.
+*/
 function Get(path) {
 	return createDecorator(GetDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Head.ts
+/**
+* A decorator class for handling HTTP HEAD requests.
+*
+* This class extends the BaseDecorator and is used to register HEAD routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<HeadDecoratorOptions>}
+*/
 var HeadDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1239,12 +1530,30 @@ var HeadDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], HeadDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], HeadDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], HeadDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a HeadDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with HEAD route information.
+*
+* @param {string} path - The path for the HEAD route.
+* @return {Function} The decorator function.
+*/
 function Head(path) {
 	return createDecorator(HeadDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Header.ts
+/**
+* A decorator class for handling HTTP header parameters.
+*
+* This class extends the BaseDecorator and is used to register header parameters
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the header information to the metadata.
+*
+* @extends {BaseDecorator<HeaderDecoratorOptions>}
+*/
 var HeaderDecorator = class extends BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1262,12 +1571,31 @@ var HeaderDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* A decorator function for handling HTTP header parameters.
+*
+* This function creates a HeaderDecorator with the specified name and registers it.
+* It is used to annotate a parameter in a method to indicate that it should be
+* populated with the value of a specific HTTP header.
+*
+* @param {string} name - The name of the HTTP header to bind to the parameter.
+* @returns {Function} - A decorator function that registers the HeaderDecorator.
+*/
 function Header(name) {
 	return createDecorator(HeaderDecorator, { name });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Headers.ts
+/**
+* This class is responsible for managing headers decorator.
+*
+* This class extends the BaseDecorator and is used to register headers parameters
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the headers information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var HeadersDecorator = class extends BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1284,12 +1612,29 @@ var HeadersDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a HeadersDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with headers information.
+*
+* @return {Function} The decorator function.
+*/
 function Headers$1() {
 	return createDecorator(HeadersDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Options.ts
+/**
+* A decorator class for handling HTTP OPTIONS requests.
+*
+* This class extends the BaseDecorator and is used to register OPTIONS routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<OptionsDecoratorOptions>}
+*/
 var OptionsDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1321,12 +1666,30 @@ var OptionsDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], OptionsDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], OptionsDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], OptionsDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating an OptionsDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with OPTIONS route information.
+*
+* @param {string} path - The path for the OPTIONS route.
+* @return {Function} The decorator function.
+*/
 function Options(path) {
 	return createDecorator(OptionsDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Param.ts
+/**
+* This class is responsible for managing parameter decorators.
+*
+* This class extends the BaseDecorator and is used to register parameter information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the parameter information to the metadata.
+*
+* @extends {BaseDecorator<ParamDecoratorOptions>}
+*/
 var ParamDecorator = class extends BaseDecorator {
 	gMetadataResolver;
 	/**
@@ -1346,12 +1709,32 @@ var ParamDecorator = class extends BaseDecorator {
 	}
 };
 __decorate([Inject(MetadataResolver)], ParamDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a ParamDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with parameter information.
+*
+* @param {string} name - The name of the parameter.
+* @param {Object} [opts] - Optional settings for the parameter.
+* @param {boolean} [opts.decode=false] - Whether to decode the parameter.
+* @return {Function} The decorator function.
+*/
 function Param(name) {
 	return createDecorator(ParamDecorator, { name });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Patch.ts
+/**
+* A decorator class for handling HTTP PATCH requests.
+*
+* This class extends the BaseDecorator and is used to register PATCH routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<PatchDecoratorOptions>}
+*/
 var PatchDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1381,12 +1764,30 @@ var PatchDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], PatchDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], PatchDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], PatchDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a PatchDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with PATCH route information.
+*
+* @param {string} path - The path for the PATCH route.
+* @return {Function} The decorator function.
+*/
 function Patch(path) {
 	return createDecorator(PatchDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Post.ts
+/**
+* A decorator class for handling HTTP POST requests.
+*
+* This class extends the BaseDecorator and is used to register POST routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<PostDecoratorOptions>}
+*/
 var PostDecorator = class extends BaseDecorator {
 	gRouter;
 	gMetadataResolver;
@@ -1418,12 +1819,30 @@ var PostDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], PostDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(MetadataResolver)], PostDecorator.prototype, "gMetadataResolver", void 0);
 __decorate([Inject(RequestHandler)], PostDecorator.prototype, "gRequestHandler", void 0);
+/**
+* A factory function for creating a PostDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with POST route information.
+*
+* @param {string} path - The path for the POST route.
+* @return {Function} The decorator function.
+*/
 function Post(path) {
 	return createDecorator(PostDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Put.ts
+/**
+* A decorator class for handling HTTP PUT requests.
+*
+* This class extends the BaseDecorator and is used to register PUT routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<PutDecoratorOptions>}
+*/
 var PutDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1455,12 +1874,30 @@ var PutDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], PutDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], PutDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], PutDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a PutDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with PUT route information.
+*
+* @param {string} path - The path for the PUT route.
+* @return {Function} The decorator function.
+*/
 function Put(path) {
 	return createDecorator(PutDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/QueryParam.ts
+/**
+* This class is responsible for managing query parameter decorators.
+*
+* This class extends the BaseDecorator and is used to register query parameter information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the query parameter information to the metadata.
+*
+* @extends {BaseDecorator<QueryDecoratorOptions>}
+*/
 var QueryParamDecorator = class extends BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1486,12 +1923,30 @@ var QueryParamDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a QueryDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with query parameter information.
+*
+* @param {QueryParamDecoratorOptions} options - The options for the decorator.
+* @return {Function} The decorator function.
+*/
 function QueryParam(options) {
 	return createDecorator(QueryParamDecorator, options);
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/QueryParams.ts
+/**
+* This class is responsible for managing query parameters decorators.
+*
+* This class extends the BaseDecorator and is used to register query parameters information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the query parameters information to the metadata.
+*
+* @extends {BaseDecorator<QueryDecoratorOptions>}
+*/
 var QueryParamsDecorator = class extends BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1517,12 +1972,30 @@ var QueryParamsDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a QueryParamsDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with query parameter information.
+*
+* @param {QueryParamsDecoratorOptions} options - The options for the decorator.
+* @return {Function} The decorator function.
+*/
 function QueryParams(options) {
 	return createDecorator(QueryParamsDecorator, options);
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Request.ts
+/**
+* This class is responsible for managing request decorators.
+*
+* This class extends the BaseDecorator and is used to register request information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the request information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var RequestDecorator = class extends BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1539,12 +2012,29 @@ var RequestDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a RequestDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with request information.
+*
+* @return {Function} The decorator function.
+*/
 function Request() {
 	return createDecorator(RequestDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Response.ts
+/**
+* This class is responsible for managing response decorators.
+*
+* This class extends the BaseDecorator and is used to register response information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the response information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var ResponseDecorator = class extends BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1561,12 +2051,29 @@ var ResponseDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a ResponseDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with response information.
+*
+* @return {Function} The decorator function.
+*/
 function Response$1() {
 	return createDecorator(ResponseDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Trace.ts
+/**
+* A decorator class for handling HTTP TRACE requests.
+*
+* This class extends the BaseDecorator and is used to register TRACE routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<TraceDecoratorOptions>}
+*/
 var TraceDecorator = class extends BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1598,12 +2105,25 @@ var TraceDecorator = class extends BaseDecorator {
 __decorate([Inject(Router)], TraceDecorator.prototype, "gRouter", void 0);
 __decorate([Inject(RequestHandler)], TraceDecorator.prototype, "gRequestHandler", void 0);
 __decorate([Inject(MetadataResolver)], TraceDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a TraceDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with TRACE route information.
+*
+* @param {string} path - The path for the TRACE route.
+* @return {Function} The decorator function.
+*/
 function Trace(path) {
 	return createDecorator(TraceDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/SetHeader.ts
+/**
+* A decorator that sets a header on the response.
+* @extends {BaseDecorator<SetHeaderDecoratorOptions>}
+*/
 var SetHeaderDecorator = class extends BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1620,6 +2140,12 @@ var SetHeaderDecorator = class extends BaseDecorator {
 		} });
 	}
 };
+/**
+* Creates a SetHeader decorator.
+* @param {string} key - The header key.
+* @param {string} value - The header value.
+* @returns {Function} The decorator function.
+*/
 function SetHeader(key, value) {
 	return createDecorator(SetHeaderDecorator, {
 		key,
@@ -1629,6 +2155,13 @@ function SetHeader(key, value) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Status.ts
+/**
+
+* A decorator that sets a status on the response.
+
+* @extends {BaseDecorator<StatusDecoratorOptions>}
+
+*/
 var StatusDecorator = class extends BaseDecorator {
 	/**
 	
@@ -1645,6 +2178,15 @@ var StatusDecorator = class extends BaseDecorator {
 		method.actions.push({ handler: () => ({ status: this.options.code }) });
 	}
 };
+/**
+
+* Creates a Status decorator.
+
+* @param {number} code - The status value.
+
+* @returns {Function} The decorator function.
+
+*/
 function Status(code) {
 	return createDecorator(StatusDecorator, { code });
 }
@@ -1674,6 +2216,17 @@ var RedirectDecorator = class extends BaseDecorator {
 		} });
 	}
 };
+/**
+
+* Creates a Redirect decorator.
+
+* @param {string} location - The location header value.
+
+* @param {number} [code=301] - The status code.
+
+* @returns {Function} The decorator function.
+
+*/
 function Redirect(location, code = 301) {
 	return createDecorator(RedirectDecorator, {
 		location,
@@ -1683,6 +2236,28 @@ function Redirect(location, code = 301) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Middleware.ts
+/**
+* Decorator that applies middleware to a class or method
+* @param middleware - The middleware class to apply
+* @param opts - Optional configuration parameters
+* @param opts.type - The type of middleware ('before' or 'after')
+* @param opts.priority - Priority order for middleware execution (default: 999)
+* @returns A decorator function that can be applied to classes or methods
+*
+* @example
+* ```typescript
+* @Middleware(AuthMiddleware)
+* class UserController {
+*   // ...
+* }
+*
+* // Or on a specific method:
+* @Middleware(ValidationMiddleware, { type: 'before', priority: 1 })
+* public async createUser() {
+*   // ...
+* }
+* ```
+*/
 function Middleware(middleware, opts) {
 	return function internalDecorator(target, propertyName) {
 		const ctx = propertyName ? target : target.prototype;
@@ -1697,6 +2272,12 @@ function Middleware(middleware, opts) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/MultipartFormData.ts
+/**
+* @class MultipartFormDataDecorator
+* @extends BaseDecorator<MultipartFormDataOptions>
+*
+* A decorator class that handles the metadata for HTTP request bodies.
+*/
 var MultipartFormDataDecorator = class extends BaseDecorator {
 	/**
 	* @method created
@@ -1712,12 +2293,35 @@ var MultipartFormDataDecorator = class extends BaseDecorator {
 		});
 	}
 };
+/**
+* Decorator function that marks a parameter as multipart/form-data request body.
+* This decorator will automatically parse incoming multipart form data
+* 
+* @decorator
+* @returns {Function} A decorator function that can be applied to method parameters
+* 
+* @example
+* class UserController {
+*   uploadFile(@MultipartFormData() formData: MyData) {
+*     // Handle multipart form data
+*   }
+* }
+*/
 function MultipartFormData() {
 	return createDecorator(MultipartFormDataDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Session.ts
+/**
+* This class is responsible for managing session decorators.
+*
+* This class extends the BaseDecorator and is used to register session information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the session information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var SessionDecorator = class extends BaseDecorator {
 	gRuntimeConfig;
 	/**
@@ -1741,12 +2345,23 @@ var SessionDecorator = class extends BaseDecorator {
 	}
 };
 __decorate([Inject(RuntimeConfig)], SessionDecorator.prototype, "gRuntimeConfig", void 0);
+/**
+* A factory function for creating a SessionDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with session information.
+*
+* @return {Function} The decorator function.
+*/
 function Session() {
 	return createDecorator(SessionDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Hooks/Listen.ts
+/**
+* This class is responsible for managing cache decorator.
+*/
 var ListenDecorator = class extends BaseDecorator {
 	gHooksService;
 	fHook;
@@ -1765,12 +2380,22 @@ var ListenDecorator = class extends BaseDecorator {
 	}
 };
 __decorate([Inject(HooksService)], ListenDecorator.prototype, "gHooksService", void 0);
+/**
+* This decorator stores metadata about hook listeners. It can be later used along with function
+* applyEventListeners() to automatically register all listeners.
+*
+* @param hookType hook to listen for
+* @return decorator function
+*/
 function Listen(hookType) {
 	return createDecorator(ListenDecorator, { hookType });
 }
 
 //#endregion
 //#region packages/core/src/Services/Plugins/BasePlugin.ts
+/**
+* Represents a Plugin.
+*/
 var BasePlugin = class {
 	/**
 	* The name of the plugin.
@@ -1786,10 +2411,17 @@ var BasePlugin = class {
 
 //#endregion
 //#region packages/core/src/Services/Middleware/BaseMiddleware.ts
+/**
+* BaseMiddleware class that serves as a base for all middleware implementations.
+*/
 var BaseMiddleware = class {};
 
 //#endregion
 //#region packages/core/src/Errors/Http/ForbiddenError.ts
+/**
+* Represents a Forbidden error (HTTP 403).
+* @extends {HttpError}
+*/
 var ForbiddenError = class ForbiddenError extends HttpError {
 	/**
 	* The name of the error.
@@ -1809,6 +2441,10 @@ var ForbiddenError = class ForbiddenError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/MethodNotAllowedError.ts
+/**
+* Represents a Method Not Allowed error (HTTP 405).
+* @extends {HttpError}
+*/
 var MethodNotAllowedError = class MethodNotAllowedError extends HttpError {
 	/**
 	* The name of the error.
@@ -1828,6 +2464,10 @@ var MethodNotAllowedError = class MethodNotAllowedError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/NotAcceptableError.ts
+/**
+* Represents a Not Acceptable error (HTTP 406).
+* @extends {HttpError}
+*/
 var NotAcceptableError = class NotAcceptableError extends HttpError {
 	/**
 	* The name of the error.
@@ -1847,6 +2487,10 @@ var NotAcceptableError = class NotAcceptableError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/NotFoundError.ts
+/**
+* Represents a Not Found error (HTTP 404).
+* @extends {HttpError}
+*/
 var NotFoundError = class NotFoundError extends HttpError {
 	/**
 	* The name of the error.
@@ -1866,6 +2510,10 @@ var NotFoundError = class NotFoundError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/UnauthorizedError.ts
+/**
+* Represents an Unauthorized error (HTTP 401).
+* @extends {HttpError}
+*/
 var UnauthorizedError = class UnauthorizedError extends HttpError {
 	/**
 	* The name of the error.
@@ -1951,4 +2599,4 @@ let HTTPStatus = /* @__PURE__ */ function(HTTPStatus$1) {
 }({});
 
 //#endregion
-export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, Connect, Controller, Delete, ForbiddenError, Get, HTTPStatus, Head, Header, Headers$1 as Headers, HooksService, HttpError, HttpServer, InternalServerError, Listen, MetadataResolver, MethodNotAllowedError, Middleware, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request, Response$1 as Response, Session, SetHeader, Status, Trace, UnauthorizedError, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };
+export { App, BadRequestError, BaseMiddleware, BasePlugin, Body, Connect, Controller, Delete, ErrorHandlerProvider, ForbiddenError, Get, GlobalMiddlewareRegistry, HTTPStatus, Head, Header, Headers$1 as Headers, HooksService, HttpError, HttpServer, InternalServerError, Listen, MetadataResolver, MethodNotAllowedError, Middleware, MultipartFormData, NotAcceptableError, NotFoundError, Options, Param, Patch, Post, Put, QueryParam, QueryParams, Redirect, Request, Response$1 as Response, Session, SetHeader, Status, Trace, UnauthorizedError, createApp, createMetadataCtx, createMetadataMethod, defineConfig, initializeMetadata, initializeMetadataMethod, loadVercubeConfig };