@vercube/core 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -1,2693 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const __vercube_di = __toESM(require("@vercube/di"));
-const srvx = __toESM(require("srvx"));
-const rou3 = __toESM(require("rou3"));
-const node_fs = __toESM(require("node:fs"));
-const node_path = __toESM(require("node:path"));
-const node_fs_promises = __toESM(require("node:fs/promises"));
-const __vercube_logger = __toESM(require("@vercube/logger"));
-const c12 = __toESM(require("c12"));
-const defu = __toESM(require("defu"));
-
-//#region node_modules/.pnpm/@oxc-project+runtime@0.65.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
-var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.65.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
-	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);
-		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-		return c > 3 && r && Object.defineProperty(target, key, r), r;
-	}
-	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-var import_decorate = __toESM(require_decorate(), 1);
-
-//#endregion
-//#region packages/core/src/Services/Plugins/PluginsRegistry.ts
-var PluginsRegistry = class {
-	gContainer;
-	/** Holds the list of plugins */
-	fPlugins = new Map();
-	/**
-	* Registers a plugin.
-	*
-	* @param {Plugin} plugin - The plugin to register.
-	* @param {unknown} options - The options to pass to the plugin.
-	*/
-	register(plugin, options) {
-		const instance = this.gContainer.resolve(plugin);
-		this.fPlugins.set(instance.name, {
-			instance,
-			options
-		});
-	}
-	/**
-	* Gets the list of registered plugins.
-	*
-	* @returns {Plugin[]} The list of registered plugins.
-	*/
-	get plugins() {
-		return [...this.fPlugins.values()].map((plugin) => plugin.instance);
-	}
-	/**
-	* Resolves the plugins.
-	*
-	* @param {App} app - The application instance.
-	*/
-	async init(app) {
-		for (const { instance, options } of this.fPlugins.values()) await instance.use(app, options);
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.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();
-	/**
-	* Registers listener for event of particular type. Everytime event is called, the listener
-	* will be executed.
-	*
-	* @param type type of event, simple class
-	* @param callback callback fired when event is triggered
-	* @returns unique ID for event listener, can be used to disable this listener
-	*/
-	on(type, callback) {
-		let handlersOfType = this.fHandlers.get(type);
-		if (!handlersOfType) {
-			handlersOfType = [];
-			this.fHandlers.set(type, handlersOfType);
-		}
-		const genId = this.fLastId++;
-		const handler = {
-			callback,
-			id: genId
-		};
-		handlersOfType.push(handler);
-		return {
-			__id: genId,
-			__type: type
-		};
-	}
-	/**
-	* Waits for single event execution and removes the listener immediately after.
-	*
-	* @example
-	* this.gCart.addItem(product);
-	* await this.gEvents.waitFor(CartUpdatedEvent);
-	* console.log('here cart updated event is already called');
-	*
-	* @param type type of event to wait for
-	* @param timeout timeout param in ms - if event is not thrown until this time, it'll reject. passing null disables the timeout
-	* @returns promise with event data that resolves when event is finally called
-	*/
-	waitFor(type, timeout = 10 * 1e3) {
-		return new Promise((resolve, reject) => {
-			let waitTimeout;
-			const eventId = this.on(type, (data) => {
-				this.off(eventId);
-				resolve(data);
-				if (waitTimeout) clearTimeout(waitTimeout);
-			});
-			if (timeout !== null) waitTimeout = setTimeout(() => {
-				this.off(eventId);
-				reject(new Error(`Waiting for event timeout - ${type.name}`));
-			}, timeout);
-		});
-	}
-	/**
-	* Removes listener from particular event.
-	* @param eventId eventId returned from .on() method.
-	* @throws Error if event was not registered
-	*/
-	off(eventId) {
-		const type = eventId.__type;
-		const handlersOfType = this.fHandlers.get(type);
-		if (!handlersOfType) throw new Error("Trying to unbind event that was not bound.");
-		const index = handlersOfType.findIndex((handler) => handler.id === eventId.__id);
-		if (index === -1) throw new Error("Trying to unbind event that was not bound.");
-		handlersOfType.splice(index, 1);
-	}
-	/**
-	* Triggers event, calling all listener callbacks. Will return Promise of number,
-	* that is resolved when all asynchronous listeners are called.
-	* @param type type of trigger, simple class
-	* @param data data which will be passed to listeners, based on event class
-	* @return number of listeners that were notified
-	*/
-	async trigger(type, data) {
-		const handlersOfType = this.fHandlers.get(type);
-		if (!handlersOfType) return 0;
-		const toProcessHandlers = [...handlersOfType];
-		const promises = toProcessHandlers.map((handler) => {
-			const instance = this.objectToClass(type, data);
-			const result = handler.callback(instance);
-			return result instanceof Promise ? result : Promise.resolve();
-		});
-		await Promise.all(promises);
-		return toProcessHandlers.length;
-	}
-	/**
-	* Converts plain object to it's class equivalent.
-	* It's NOT class-transformer, it performs basic key assigment.
-	*
-	* @param ClassConstructor event constructor
-	* @param data event data to be mapped to constructor
-	* @return class type of event
-	*/
-	objectToClass(ClassConstructor, data) {
-		const instance = new ClassConstructor();
-		if (data) for (const key of Object.keys(data)) {
-			const rawInstance = instance;
-			const rawData = data;
-			rawInstance[key] = rawData[key];
-		}
-		return instance;
-	}
-};
-
-//#endregion
-//#region packages/core/src/Hooks/Router/RouterBeforeInitHook.ts
-var RouterBeforeInitHook = class {};
-
-//#endregion
-//#region packages/core/src/Hooks/Router/RouterAfterInitHook.ts
-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
-	*/
-	gHooksService;
-	/**
-	* Internal router context that stores all registered routes
-	* @private
-	*/
-	fRouterContext;
-	/**
-	* Registers a new route in the router
-	* 
-	* @param {RouterTypes.Route} route - The route configuration to add
-	* @throws {Error} If router is not initialized
-	*/
-	addRoute(route) {
-		if (!this.fRouterContext) throw new Error("Router not initialized. Please call init() before adding routes.");
-		(0, rou3.addRoute)(this.fRouterContext, route.method.toUpperCase(), route.path, route.handler);
-	}
-	/**
-	* Initializes the router and triggers related hooks
-	* 
-	* This method creates a new router context and triggers
-	* the before and after initialization hooks.
-	*/
-	initialize() {
-		this.gHooksService.trigger(RouterBeforeInitHook);
-		this.fRouterContext = (0, rou3.createRouter)();
-		this.gHooksService.trigger(RouterAfterInitHook);
-	}
-	/**
-	* Resolves a route based on the HTTP method and path
-	* 
-	* @param {RouterTypes.RouteFind} route - The route to resolve
-	* @returns {RouterTypes.RouteMatched<RouterTypes.RouterHandler> | undefined} The matched route or undefined if no match found
-	*/
-	resolve(route) {
-		let url = route.path;
-		try {
-			url = new URL(route.path).pathname;
-		} catch {}
-		return (0, rou3.findRoute)(this.fRouterContext, route.method.toUpperCase(), url);
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.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.
-	* @type {number}
-	*/
-	status;
-	/**
-	* Creates an instance of HttpError.
-	* @param {number} status - The HTTP status code.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(status, message) {
-		super();
-		Object.setPrototypeOf(this, HttpError.prototype);
-		if (status) this.status = status;
-		if (message) this.message = message;
-		this.stack = new Error().stack;
-	}
-};
-
-//#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.
-	* @type {string}
-	*/
-	name = "BadRequestError";
-	/**
-	* Creates an instance of BadRequestError.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(message, errors) {
-		super(400);
-		Object.setPrototypeOf(this, BadRequestError.prototype);
-		if (message) this.message = message;
-		if (errors) this.errors = errors;
-	}
-};
-
-//#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;
-	try {
-		return JSON.parse(text);
-	} catch {
-		throw new BadRequestError("Invalid JSON body");
-	}
-}
-
-//#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 = {};
-	for (const [key, value] of url.searchParams) params[key] = value;
-	return params;
-}
-
-//#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.
-	*
-	* @param {MetadataTypes.ResolveUrlParams} params - The parameters for resolving the URL.
-	* @return {string} The resolved URL.
-	*/
-	resolveUrl(params) {
-		const { instance, propertyName, path: rawPath } = params;
-		const metadata = instance.__metadata;
-		const basePath = (metadata?.__controller?.path ?? "").replace(/\/$/, "");
-		const cleanPath = rawPath.replace(/^\//, "");
-		const url = `${basePath}/${cleanPath}`;
-		metadata.__methods[propertyName].url = url;
-		return url;
-	}
-	resolveMethod(ctx, propertyName) {
-		return ctx.__metadata.__methods[propertyName];
-	}
-	/**
-	* Resolves arguments for a given event.
-	*
-	* @param {MetadataTypes.Arg[]} args - The arguments to resolve.
-	* @param {RouterTypes.RouterEvent} event - The event to resolve arguments for.
-	* @return {unknown[]} The resolved arguments.
-	* @public
-	*/
-	async resolveArgs(args, event) {
-		args.sort((a, b) => a.idx - b.idx);
-		const resolvedArgs = args.map(async (arg) => ({
-			...arg,
-			resolved: await this.resolveArg(arg, event)
-		}));
-		return await Promise.all(resolvedArgs);
-	}
-	/**
-	* Resolves an argument for a given event.
-	*
-	* @param {MetadataTypes.Arg} arg - The argument to resolve.
-	* 
-	* @return {unknown} The resolved argument.
-	* @private
-	*/
-	resolveArg(arg, event) {
-		switch (arg.type) {
-			case "param": return resolveRouterParam(arg?.data?.name ?? "", event);
-			case "body": return resolveRequestBody(event);
-			case "multipart-form-data": return null;
-			case "query-param": return resolveQueryParam(arg?.data?.name ?? "", event);
-			case "query-params": return resolveQueryParams(event);
-			case "header": return getRequestHeader(arg.data?.name ?? "", event);
-			case "headers": return getRequestHeaders(event);
-			case "request": return event.request;
-			case "response": return event.response;
-			case "custom": return arg.data?.resolve(event);
-			case "session": return null;
-			default: throw new Error(`Unknown argument type: ${arg.type}`);
-		}
-	}
-	/**
-	* Resolves middleware functions for a given context and property name.
-	*
-	* @param {MetadataTypes.Ctx} ctx - The metadata context object
-	* @param {string} propertyName - The name of the property to resolve middlewares for
-	* @returns {MetadataTypes.Middleware[]} Array of middleware functions that apply globally or to the specific property
-	* @public
-	*/
-	resolveMiddlewares(ctx, propertyName) {
-		const middlewares = ctx?.__metadata?.__middlewares?.filter((m) => m.target === "__global__" || m.target === propertyName) ?? [];
-		return middlewares.sort((a) => a.target === "__global__" ? -1 : 1);
-	}
-};
-
-//#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();
-	/**
-	* Retrieves all registered global middleware configurations
-	* 
-	* @returns {MetadataTypes.Middleware[]} An array of middleware configurations
-	*/
-	get middlewares() {
-		return [...this.fMiddlewares.values()].map((m) => ({
-			...m.opts,
-			target: "__global__",
-			middleware: m.middleware
-		}));
-	}
-	/**
-	* Registers a global middleware configuration
-	* 
-	* @param {typeof BaseMiddleware<T, U>} middleware - The middleware class to register
-	* @param {GlobalMiddlewareParams<T>} opts - The middleware options
-	* @returns {void}
-	*/
-	registerGlobalMiddleware(middleware, opts) {
-		this.fMiddlewares.add({
-			middleware,
-			opts
-		});
-	}
-};
-
-//#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;
-	gGlobalMiddlewareRegistry;
-	/**
-	* Prepares a route handler by resolving its metadata and middlewares
-	* 
-	* @param {RequestHandlerOptions} params - Configuration options for the handler
-	* @returns {RouterTypes.RouterHandler} A prepared handler with resolved metadata and middlewares
-	*/
-	prepareHandler(params) {
-		const { instance, propertyName } = params;
-		const prototype = Object.getPrototypeOf(instance);
-		const method = this.gMetadataResolver.resolveMethod(prototype, propertyName);
-		const middlewares = this.gMetadataResolver.resolveMiddlewares(prototype, propertyName);
-		const globalMiddlewares = this.gGlobalMiddlewareRegistry.middlewares;
-		const uniqueMiddlewares = [...middlewares, ...globalMiddlewares].filter((m, index, self) => self.findIndex((t) => t.middleware === m.middleware) === index);
-		const resolvedMiddlewares = uniqueMiddlewares.map((m) => ({
-			...m,
-			middleware: this.gContainer.resolve(m.middleware)
-		}));
-		const beforeMiddlewares = resolvedMiddlewares.filter((m) => !!m.middleware.onRequest);
-		const afterMiddlewares = resolvedMiddlewares.filter((m) => !!m.middleware.onResponse);
-		beforeMiddlewares.sort((a, b) => (a?.priority ?? 999) - (b?.priority ?? 999));
-		afterMiddlewares.sort((a, b) => (a?.priority ?? 999) - (b?.priority ?? 999));
-		return {
-			instance,
-			propertyName,
-			args: method.args,
-			middlewares: {
-				beforeMiddlewares,
-				afterMiddlewares
-			},
-			actions: method.actions
-		};
-	}
-	/**
-	* Processes an HTTP request through the middleware chain and route handler
-	* 
-	* The request handling lifecycle:
-	* 1. Execute "before" middlewares
-	* 2. Apply route actions (status codes, redirects, etc.)
-	* 3. Resolve handler arguments
-	* 4. Execute the route handler
-	* 5. Execute "after" middlewares
-	* 6. Format and return the final response
-	* 
-	* @param {Request} request - The incoming HTTP request
-	* @param {RouterTypes.RouteMatched<RouterTypes.RouterHandler>} route - The matched route with handler data
-	* @returns {Promise<Response>} The HTTP response
-	*/
-	async handleRequest(request, route) {
-		try {
-			const { instance, propertyName, actions, args, middlewares } = route.data;
-			let fakeResponse = new Response(void 0, { headers: { "Content-Type": request.headers.get("Content-Type") ?? "application/json" } });
-			for await (const hook of middlewares?.beforeMiddlewares ?? []) try {
-				const hookResponse = await hook.middleware.onRequest?.(request, fakeResponse, {
-					middlewareArgs: hook.args,
-					methodArgs: args
-				});
-				if (hookResponse instanceof Response) return hookResponse;
-			} catch (error_) {
-				this.gContainer.get(ErrorHandlerProvider).handleError(error_);
-			}
-			for (const action of actions) {
-				const actionResponse = action.handler(request, fakeResponse);
-				if (actionResponse !== null) fakeResponse = this.processOverrideResponse(actionResponse, fakeResponse);
-			}
-			const resolvedArgs = await this.gMetadataResolver.resolveArgs(args, {
-				...route,
-				request,
-				response: fakeResponse
-			});
-			let handlerResponse = instance[propertyName].call(instance, ...resolvedArgs?.map((a) => a.resolved) ?? []);
-			if (handlerResponse instanceof Promise) handlerResponse = await handlerResponse;
-			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_) {
-				this.gContainer.get(ErrorHandlerProvider).handleError(error_);
-			}
-			const body = fakeResponse?.body ?? JSON.stringify(handlerResponse);
-			return new Response(body, {
-				status: fakeResponse.status,
-				statusText: fakeResponse.statusText,
-				headers: fakeResponse.headers
-			});
-		} catch (error_) {
-			return this.gContainer.get(ErrorHandlerProvider).handleError(error_);
-		}
-	}
-	/**
-	* Processes and merges response overrides from middlewares or actions
-	* 
-	* This method handles different response formats:
-	* - If a full Response object is provided, it's used directly
-	* - If ResponseInit is provided, it's merged with the base response
-	* 
-	* @param {Response | ResponseInit} response - The response or response options to apply
-	* @param {Response} [base] - The base response to extend (optional)
-	* @returns {Response} The processed response with applied overrides
-	* @private
-	*/
-	processOverrideResponse(response, base) {
-		let fakeResponse = base ?? new Response();
-		if (response != null && response instanceof Response) return response;
-		else if (response !== null) {
-			const responseInit = response;
-			fakeResponse = new Response(void 0, {
-				status: responseInit?.status ?? fakeResponse.status,
-				headers: responseInit?.headers ?? fakeResponse.headers,
-				statusText: responseInit?.statusText ?? fakeResponse.statusText
-			});
-		}
-		return fakeResponse;
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], RequestHandler.prototype, "gMetadataResolver", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], RequestHandler.prototype, "gContainer", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(GlobalMiddlewareRegistry)], RequestHandler.prototype, "gGlobalMiddlewareRegistry", void 0);
-
-//#endregion
-//#region packages/core/src/Utils/Mine.ts
-const mime = { getType(ext) {
-	const types = {
-		".html": "text/html",
-		".css": "text/css",
-		".js": "application/javascript",
-		".json": "application/json",
-		".png": "image/png",
-		".jpg": "image/jpeg",
-		".jpeg": "image/jpeg",
-		".gif": "image/gif",
-		".svg": "image/svg+xml",
-		".ico": "image/x-icon"
-	};
-	return types[ext] || null;
-} };
-
-//#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
-	*/
-	fOptions;
-	/**
-	* Initializes the static server with the given options
-	* 
-	* @param {ConfigTypes.ServerOptions['static']} options - The options for the static server
-	* @returns {void}
-	*/
-	initialize(options) {
-		this.fOptions = options;
-	}
-	/**
-	* Handles HTTP requests for static files
-	* 
-	* @param {Request} request - The incoming HTTP request
-	* @returns {Promise<void | Response>} A promise that resolves to void or a Response object
-	*/
-	async handleRequest(request) {
-		const dirs = this.fOptions?.dirs ?? [];
-		if (!dirs) return;
-		if (request.method !== "GET") return;
-		const url = new URL(request.url);
-		const path = (0, node_path.normalize)(url.pathname);
-		let relativePath = path;
-		for (const dir of dirs) relativePath = relativePath.replace(dir, "");
-		for (const dir of dirs) {
-			const fullPath = (0, node_path.join)(process.cwd(), dir, relativePath);
-			try {
-				const stats = await (0, node_fs_promises.stat)(fullPath);
-				if (stats.isDirectory()) continue;
-				if (stats.isFile()) return this.serveFile(fullPath, stats);
-			} catch {
-				continue;
-			}
-		}
-	}
-	/**
-	* Serves a static file and returns a Response object
-	* 
-	* @param {string} path - The path to the file to serve
-	* @param {any} stats - The stats object for the file
-	* @returns {Promise<Response>} A promise that resolves to a Response object
-	*/
-	async serveFile(path, stats) {
-		const headers = new Headers();
-		const ext = (0, node_path.extname)(path).toLowerCase();
-		const contentType = mime.getType(ext) || "application/octet-stream";
-		headers.set("Content-Type", contentType);
-		headers.set("Content-Length", stats.size.toString());
-		if (this.fOptions?.maxAge && this.fOptions.maxAge > 0) {
-			const directives = ["public", `max-age=${this.fOptions.maxAge}`];
-			if (this.fOptions?.immutable) directives.push("immutable");
-			headers.set("Cache-Control", directives.join(", "));
-		}
-		if (this.fOptions?.etag) headers.set("ETag", `W/"${stats.size}-${stats.mtime.getTime()}"`);
-		const stream = (0, node_fs.createReadStream)(path);
-		return new Response(stream, { headers });
-	}
-};
-
-//#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
-	*/
-	gRouter;
-	/**
-	* Handler for processing HTTP requests
-	*/
-	gRequestHandler;
-	/**
-	* Static server for serving static files
-	*/
-	gStaticRequestHandler;
-	/**
-	* Underlying server instance
-	* @private
-	*/
-	fServer;
-	/**
-	* Initializes the HTTP server and starts listening for requests
-	* 
-	* @returns {Promise<void>} A promise that resolves when the server is ready
-	*/
-	async initialize(config) {
-		const { port, host } = config.server ?? {};
-		this.fServer = (0, srvx.serve)({
-			bun: { error: (error) => {
-				return this.gContainer.get(ErrorHandlerProvider).handleError(error);
-			} },
-			deno: { onError: (error) => {
-				return this.gContainer.get(ErrorHandlerProvider).handleError(error);
-			} },
-			hostname: host,
-			port,
-			fetch: this.handleRequest.bind(this)
-		});
-	}
-	/**
-	* Listens for incoming requests on the HTTP server
-	* 
-	* @returns {Promise<void>} A promise that resolves when the server is ready to listen
-	*/
-	async listen() {
-		await this.fServer.ready();
-	}
-	/**
-	* Processes an incoming HTTP request
-	* 
-	* This method:
-	* 1. Resolves the route for the request
-	* 2. Returns a 404 response if no route is found
-	* 3. Delegates to the request handler for matched routes
-	* 
-	* @param {Request} request - The incoming HTTP request
-	* @returns {Promise<Response>} The HTTP response
-	* @private
-	*/
-	async handleRequest(request) {
-		try {
-			const route = this.gRouter.resolve({
-				path: request.url,
-				method: request.method
-			});
-			if (!route) {
-				const response = await this.gStaticRequestHandler.handleRequest(request);
-				if (response) return response;
-				else throw new NotFoundError("Route not found");
-			}
-			return this.gRequestHandler.handleRequest(request, route);
-		} catch (error) {
-			return this.gContainer.get(ErrorHandlerProvider).handleError(error);
-		}
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], HttpServer.prototype, "gContainer", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], HttpServer.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], HttpServer.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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;
-	gHttpServer;
-	gStaticRequestHandler;
-	gLogger;
-	/** Holds the initialization status of the application */
-	fIsInitialized = false;
-	/** Holds the dependency injection container */
-	fInternalContainer;
-	/** Hold app config */
-	fConfig;
-	/**
-	* Gets the dependency injection container.
-	*
-	* @returns {Container} The dependency injection container.
-	*/
-	get container() {
-		return this.fInternalContainer;
-	}
-	/**
-	* Sets the dependency injection container.
-	*
-	* @param {Container} container - The dependency injection container.
-	*/
-	set container(container) {
-		this.fInternalContainer = container;
-	}
-	/**
-	* Initializes the application.
-	*
-	* @returns {Promise<void>} A promise that resolves when the application is initialized.
-	*/
-	async init(cfg) {
-		this.fConfig = cfg;
-		await this.gHttpServer.initialize(this.fConfig);
-		if (this.fConfig.server?.static) this.gStaticRequestHandler.initialize(this.fConfig.server?.static);
-		this.gRouter.initialize();
-	}
-	/**
-	* Registers a plugin.
-	*
-	* @param {typeof Plugin} plugin - The plugin to register.
-	* @param {unknown} options - The options to pass to the plugin.
-	*/
-	registerPlugin(plugin, options) {
-		this.gPluginsRegistry.register(plugin, options);
-	}
-	/**
-	* Starts the application and begins listening for incoming requests.
-	*
-	* @returns {Promise<void>} A promise that resolves when the application starts listening.
-	* @throws {Error} If the application is already initialized.
-	*/
-	async listen() {
-		if (this.fIsInitialized) throw new Error("App is already initialized");
-		await this.resolvePlugins();
-		(0, __vercube_di.initializeContainer)(this.container);
-		await this.gHttpServer.listen();
-		this.gLogger?.info(`\n${__vercube_logger.colors.green("➜")} App listening on port ${__vercube_logger.colors.bold(this.fConfig.server?.port?.toString() ?? "3000")}`);
-		this.fIsInitialized = true;
-	}
-	/**
-	* Handles an incoming HTTP request.
-	* This method is an adapter for HttpServer.handleRequest method.
-	* 
-	* @param {Request} request - The incoming HTTP request
-	* @returns {Promise<Response>} The HTTP response
-	*/
-	async fetch(request) {
-		return this.gHttpServer.handleRequest(request);
-	}
-	/**
-	* Resolves and initializes the plugins for the application.
-	*
-	* @private
-	*/
-	async resolvePlugins() {
-		await this.gPluginsRegistry.init(this);
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], App.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(PluginsRegistry)], App.prototype, "gPluginsRegistry", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(HttpServer)], App.prototype, "gHttpServer", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(StaticRequestHandler)], App.prototype, "gStaticRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(__vercube_logger.Logger)], App.prototype, "gLogger", void 0);
-
-//#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) => {
-	const wrappedFn = (text) => {
-		return isColorAllowed() ? colorFn(text) : text;
-	};
-	return wrappedFn;
-};
-const colors = {
-	bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
-	green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
-	yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
-	red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
-	magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
-	cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
-};
-const LOG_LEVEL_COLORS = {
-	debug: colors.green,
-	info: colors.bold,
-	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.
-	* This method should be called before using the appender to process messages.
-	*/
-	initialize() {}
-	/**
-	* Prints a log message according to the specified format and level.
-	* @param message - The log message object containing level, tag, and arguments
-	* @protected
-	*/
-	processMessage(message) {
-		const date = message.timestamp ? new Date(message.timestamp) : new Date();
-		console[message.level](`%s%s${message?.tag ? "%s" : ""} %s`, LOG_LEVEL_COLORS[message.level](`[${date.toISOString().split("T")[1]?.replace("Z", "")}]`), LOG_LEVEL_COLORS[message.level](`[${message.level.toUpperCase().padEnd(5, " ")}]`), message?.tag ? LOG_LEVEL_COLORS[message.level](`[${message.tag}]`) : "", ...message.args);
-	}
-};
-
-//#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
-	* @param {ValidationTypes.Schema} schema - The schema to validate against
-	* @param {ValidationTypes.Input} data - The data to validate
-	* @return {ValidationTypes.Result | Promise<ValidationTypes.Result>} The validation result
-	*/
-	validate(schema, data) {
-		return schema["~standard"].validate(data);
-	}
-};
-
-//#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.
-	* @private
-	*/
-	fRuntimeConfig;
-	/**
-	* Gets the current runtime configuration.
-	* @returns {ConfigTypes.RuntimeConfig} The current runtime configuration object.
-	*/
-	get runtimeConfig() {
-		return this.fRuntimeConfig;
-	}
-	/**
-	* Sets the runtime configuration.
-	* @param {ConfigTypes.RuntimeConfig} value - The new runtime configuration object to set.
-	*/
-	set runtimeConfig(value) {
-		this.fRuntimeConfig = value;
-	}
-};
-
-//#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.
-	* @type {string}
-	*/
-	name = "InternalServerError";
-	/**
-	* Creates an instance of InternalServerError.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(message) {
-		super(500);
-		Object.setPrototypeOf(this, InternalServerError.prototype);
-		if (message) this.message = message;
-	}
-};
-
-//#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(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 }, void 0, 2), { status });
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_logger.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 __vercube_di.Container();
-	container.bindInstance(__vercube_di.Container, container);
-	container.bind(__vercube_logger.Logger, __vercube_logger.BaseLogger);
-	container.get(__vercube_logger.Logger).configure({
-		logLevel: config.logLevel ?? "debug",
-		providers: [{
-			name: "console",
-			provider: ConsoleProvider
-		}]
-	});
-	container.bind(ErrorHandlerProvider, DefaultErrorHandlerProvider);
-	container.bind(HttpServer);
-	container.bind(StaticRequestHandler);
-	container.bind(Router);
-	container.bind(HooksService);
-	container.bind(MetadataResolver);
-	container.bind(PluginsRegistry);
-	container.bind(RequestHandler);
-	container.bind(RuntimeConfig);
-	container.bind(GlobalMiddlewareRegistry);
-	container.bind(ValidationProvider, StandardSchemaValidationProvider);
-	return container;
-}
-
-//#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);
-	return `${hashByPerformance}-${hashByMath()}-${hashByMath()}-${hashByMath()}`;
-}
-
-//#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,
-	dev: false,
-	build: {
-		root: process.cwd(),
-		entry: "src/index.ts",
-		output: {
-			dir: "dist",
-			publicDir: "public"
-		},
-		bundler: "rolldown"
-	},
-	server: {
-		runtime: "node",
-		host: "localhost",
-		port: 3e3,
-		https: false,
-		static: { dirs: ["public"] }
-	},
-	experimental: {},
-	runtime: { session: {
-		secret: process.env?.SECRET ?? generateRandomHash(),
-		name: "vercube_session",
-		duration: 60 * 60 * 24 * 7
-	} }
-};
-
-//#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 (0, c12.loadConfig)({
-		name: "vercube",
-		dotenv: true,
-		rcFile: false,
-		globalRc: false,
-		defaults: defaultConfig
-	});
-	return (0, defu.defu)(overrides ?? {}, config?.config ?? {});
-}
-
-//#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);
-	const app = container.resolve(App);
-	container.get(RuntimeConfig).runtimeConfig = config?.runtime ?? {};
-	app.container = container;
-	await app.init(config);
-	(0, __vercube_di.initializeContainer)(container);
-	return app;
-}
-
-//#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;
-	/**
-	* Middleware function that processes the HTTP event
-	* @param {Request} request - The HTTP request object
-	* @param {Response} response - The HTTP response object
-	* @param {MiddlewareOptions} args - Additional arguments for the middleware
-	* @returns {Promise<void>} - A promise that resolves when the processing is complete
-	* @throws {BadRequestError} - If validation fails
-	*/
-	async onRequest(request, response, args) {
-		if (!this.gValidationProvider) {
-			console.warn("ValidationMiddleware::ValidationProvider is not registered");
-			return;
-		}
-		const validators = args.methodArgs?.filter((arg) => arg.validate && arg.validationSchema) ?? [];
-		for (const validator of validators) {
-			const result = await this.gValidationProvider.validate(validator.validationSchema, validator.resolved);
-			if (result.issues?.length) throw new BadRequestError(`Validation error - ${validator.type}`, result.issues);
-		}
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.InjectOptional)(ValidationProvider)], ValidationMiddleware.prototype, "gValidationProvider", void 0);
-
-//#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: "" },
-		__middlewares: [],
-		__methods: {}
-	};
-}
-/**
-* Creates a new metadata method.
-* @returns {MetadataTypes.Method} The new metadata method.
-*/
-function createMetadataMethod() {
-	return {
-		req: null,
-		res: null,
-		url: null,
-		args: [],
-		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 = {};
-	if (!target.__metadata.__middlewares) target.__metadata.__middlewares = [];
-	return target.__metadata;
-}
-
-//#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 __vercube_di.BaseDecorator {
-	/**
-	* @method created
-	* This method is called when the decorator is created. It ensures that the metadata
-	* for the property exists and adds the body argument to the metadata.
-	*/
-	created() {
-		const meta = initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "body",
-			validate: this.options?.validationSchema ? true : false,
-			validationSchema: this.options?.validationSchema
-		});
-		meta.__middlewares.unshift({
-			target: this.propertyName,
-			priority: -1,
-			args: {},
-			middleware: ValidationMiddleware
-		});
-	}
-};
-/**
-* @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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the CONNECT request.
-	*/
-	created() {
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "CONNECT",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], ConnectDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], ConnectDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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);
-		meta.__controller = {
-			...meta?.__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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the DELETE request.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "DELETE",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], DeleteDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], DeleteDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the GET request.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "GET",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], GetDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], GetDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the HEAD request.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "HEAD",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], HeadDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], HeadDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the header information to the metadata.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "header",
-			data: { name: this.options.name }
-		});
-	}
-};
-/**
-* 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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the headers information to the metadata.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "headers"
-		});
-	}
-};
-/**
-* 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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the OPTIONS request.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "OPTIONS",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], OptionsDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], OptionsDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the parameter information to the metadata.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "param",
-			data: { name: this.options.name }
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the PATCH request.
-	*/
-	created() {
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "PATCH",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], PatchDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], PatchDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gMetadataResolver;
-	gRequestHandler;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the POST request.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "POST",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], PostDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], PostDecorator.prototype, "gMetadataResolver", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the PUT request.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "PUT",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], PutDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], PutDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the query parameter information to the metadata.
-	*/
-	created() {
-		const meta = initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "query-param",
-			data: { name: this.options.name },
-			validate: this.options?.validationSchema ? true : false,
-			validationSchema: this.options?.validationSchema
-		});
-		meta.__middlewares.unshift({
-			target: this.propertyName,
-			priority: -1,
-			args: {},
-			middleware: ValidationMiddleware
-		});
-	}
-};
-/**
-* 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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the query parameters information to the metadata.
-	*/
-	created() {
-		const meta = initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "query-params",
-			data: {},
-			validate: this.options?.validationSchema ? true : false,
-			validationSchema: this.options?.validationSchema
-		});
-		meta.__middlewares.unshift({
-			target: this.propertyName,
-			priority: -1,
-			args: {},
-			middleware: ValidationMiddleware
-		});
-	}
-};
-/**
-* 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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the request information to the metadata.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "request"
-		});
-	}
-};
-/**
-* 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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the response information to the metadata.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "response"
-		});
-	}
-};
-/**
-* 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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRouter;
-	gRequestHandler;
-	gMetadataResolver;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method constructs the full path for the route, registers the route
-	* with the Router, and sets up the event handler for the TRACE request.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		initializeMetadataMethod(this.prototype, this.propertyName);
-		this.options.path = this.gMetadataResolver.resolveUrl({
-			instance: this.instance,
-			path: this.options.path,
-			propertyName: this.propertyName
-		});
-		this.gRouter.addRoute({
-			path: this.options.path,
-			method: "TRACE",
-			handler: this.gRequestHandler.prepareHandler({
-				instance: this.instance,
-				propertyName: this.propertyName
-			})
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], TraceDecorator.prototype, "gRouter", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], TraceDecorator.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	/**
-	* Called when the decorator is created.
-	* Adds a query parameter to the metadata.
-	* @override
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.actions.push({ handler: (req, res) => {
-			res.headers.delete(this.options.key);
-			res.headers.append(this.options.key, this.options.value);
-			return res;
-		} });
-	}
-};
-/**
-* 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 (0, __vercube_di.createDecorator)(SetHeaderDecorator, {
-		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 __vercube_di.BaseDecorator {
-	/**
-	
-	* Called when the decorator is created.
-	
-	* Sets a status on the response
-	
-	* @override
-	
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		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 (0, __vercube_di.createDecorator)(StatusDecorator, { code });
-}
-
-//#endregion
-//#region packages/core/src/Decorators/Http/Redirect.ts
-var RedirectDecorator = class extends __vercube_di.BaseDecorator {
-	/**
-	
-	* Decorator responsible for redirecting to a specified URL.
-	
-	* Called when the decorator is created.
-	
-	* Sets the location header value and status code.
-	
-	* @override
-	
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.actions.push({ handler: () => {
-			return new Response(void 0, {
-				status: this.options.code,
-				headers: { "Location": this.options.location }
-			});
-		} });
-	}
-};
-/**
-
-* 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 (0, __vercube_di.createDecorator)(RedirectDecorator, {
-		location,
-		code
-	});
-}
-
-//#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;
-		const meta = initializeMetadata(ctx);
-		meta.__middlewares.push({
-			target: propertyName ?? "__global__",
-			priority: opts?.priority ?? 999,
-			middleware
-		});
-	};
-}
-
-//#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 __vercube_di.BaseDecorator {
-	/**
-	* @method created
-	* This method is called when the decorator is created. It ensures that the metadata
-	* for the property exists and adds the body argument to the metadata.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "multipart-form-data"
-		});
-	}
-};
-/**
-* 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 (0, __vercube_di.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 __vercube_di.BaseDecorator {
-	gRuntimeConfig;
-	/**
-	* Called when the decorator is created.
-	*
-	* This method checks if metadata for the property exists, creates it if it doesn't,
-	* and then adds the session information to the metadata.
-	*/
-	created() {
-		initializeMetadata(this.prototype);
-		const method = initializeMetadataMethod(this.prototype, this.propertyName);
-		method.args.push({
-			idx: this.propertyIndex,
-			type: "session",
-			data: {
-				name: this.gRuntimeConfig.runtimeConfig.session?.name ?? "vercube_session",
-				secret: this.gRuntimeConfig.runtimeConfig.session?.secret ?? generateRandomHash(),
-				duration: this.gRuntimeConfig.runtimeConfig.session?.duration ?? 60 * 60 * 24 * 7
-			}
-		});
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.createDecorator)(SessionDecorator, {});
-}
-
-//#endregion
-//#region packages/core/src/Decorators/Hooks/Listen.ts
-/**
-* This class is responsible for managing cache decorator.
-*/
-var ListenDecorator = class extends __vercube_di.BaseDecorator {
-	gHooksService;
-	fHook;
-	/**
-	* Called when decorator is initialized. It will register event listener that will call this function
-	* once executed.
-	*/
-	created() {
-		this.fHook = this.gHooksService.on(this.options.hookType, (data) => this.instance[this.propertyName](data));
-	}
-	/**
-	* Called when decorator is destroyed. It will unregister event listener.
-	*/
-	destroyed() {
-		this.gHooksService.off(this.fHook);
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.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 (0, __vercube_di.createDecorator)(ListenDecorator, { hookType });
-}
-
-//#endregion
-//#region packages/core/src/Services/Plugins/BasePlugin.ts
-/**
-* Represents a Plugin.
-*/
-var BasePlugin = class {
-	/**
-	* The name of the plugin.
-	*/
-	name;
-	/**
-	* Uses the plugin with the given app.
-	* @param {App} app - The application instance.
-	* @returns {void | Promise<void>} - A void or a promise that resolves to void.
-	*/
-	use(app, options) {}
-};
-
-//#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.
-	* @type {string}
-	*/
-	name = "ForbiddenError";
-	/**
-	* Creates an instance of ForbiddenError.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(message) {
-		super(403);
-		Object.setPrototypeOf(this, ForbiddenError.prototype);
-		if (message) this.message = message;
-	}
-};
-
-//#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.
-	* @type {string}
-	*/
-	name = "MethodNotAllowedError";
-	/**
-	* Creates an instance of MethodNotAllowedError.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(message) {
-		super(405);
-		Object.setPrototypeOf(this, MethodNotAllowedError.prototype);
-		if (message) this.message = message;
-	}
-};
-
-//#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.
-	* @type {string}
-	*/
-	name = "NotAcceptableError";
-	/**
-	* Creates an instance of NotAcceptableError.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(message) {
-		super(406);
-		Object.setPrototypeOf(this, NotAcceptableError.prototype);
-		if (message) this.message = message;
-	}
-};
-
-//#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.
-	* @type {string}
-	*/
-	name = "NotFoundError";
-	/**
-	* Creates an instance of NotFoundError.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(message) {
-		super(404);
-		Object.setPrototypeOf(this, NotFoundError.prototype);
-		if (message) this.message = message;
-	}
-};
-
-//#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.
-	* @type {string}
-	*/
-	name = "UnauthorizedError";
-	/**
-	* Creates an instance of UnauthorizedError.
-	* @param {string} [message] - The error message.
-	*/
-	constructor(message) {
-		super(401);
-		Object.setPrototypeOf(this, UnauthorizedError.prototype);
-		if (message) this.message = message;
-	}
-};
-
-//#endregion
-//#region packages/core/src/Types/HttpTypes.ts
-let HTTPStatus = /* @__PURE__ */ function(HTTPStatus$1) {
-	HTTPStatus$1[HTTPStatus$1["CONTINUE"] = 100] = "CONTINUE";
-	HTTPStatus$1[HTTPStatus$1["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
-	HTTPStatus$1[HTTPStatus$1["PROCESSING"] = 102] = "PROCESSING";
-	HTTPStatus$1[HTTPStatus$1["OK"] = 200] = "OK";
-	HTTPStatus$1[HTTPStatus$1["CREATED"] = 201] = "CREATED";
-	HTTPStatus$1[HTTPStatus$1["ACCEPTED"] = 202] = "ACCEPTED";
-	HTTPStatus$1[HTTPStatus$1["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
-	HTTPStatus$1[HTTPStatus$1["NO_CONTENT"] = 204] = "NO_CONTENT";
-	HTTPStatus$1[HTTPStatus$1["RESET_CONTENT"] = 205] = "RESET_CONTENT";
-	HTTPStatus$1[HTTPStatus$1["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
-	HTTPStatus$1[HTTPStatus$1["MULTI_STATUS"] = 207] = "MULTI_STATUS";
-	HTTPStatus$1[HTTPStatus$1["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
-	HTTPStatus$1[HTTPStatus$1["IM_USED"] = 226] = "IM_USED";
-	HTTPStatus$1[HTTPStatus$1["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
-	HTTPStatus$1[HTTPStatus$1["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
-	HTTPStatus$1[HTTPStatus$1["FOUND"] = 302] = "FOUND";
-	HTTPStatus$1[HTTPStatus$1["SEE_OTHER"] = 303] = "SEE_OTHER";
-	HTTPStatus$1[HTTPStatus$1["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
-	HTTPStatus$1[HTTPStatus$1["USE_PROXY"] = 305] = "USE_PROXY";
-	HTTPStatus$1[HTTPStatus$1["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
-	HTTPStatus$1[HTTPStatus$1["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
-	HTTPStatus$1[HTTPStatus$1["BAD_REQUEST"] = 400] = "BAD_REQUEST";
-	HTTPStatus$1[HTTPStatus$1["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
-	HTTPStatus$1[HTTPStatus$1["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
-	HTTPStatus$1[HTTPStatus$1["FORBIDDEN"] = 403] = "FORBIDDEN";
-	HTTPStatus$1[HTTPStatus$1["NOT_FOUND"] = 404] = "NOT_FOUND";
-	HTTPStatus$1[HTTPStatus$1["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
-	HTTPStatus$1[HTTPStatus$1["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
-	HTTPStatus$1[HTTPStatus$1["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
-	HTTPStatus$1[HTTPStatus$1["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
-	HTTPStatus$1[HTTPStatus$1["CONFLICT"] = 409] = "CONFLICT";
-	HTTPStatus$1[HTTPStatus$1["GONE"] = 410] = "GONE";
-	HTTPStatus$1[HTTPStatus$1["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
-	HTTPStatus$1[HTTPStatus$1["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
-	HTTPStatus$1[HTTPStatus$1["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
-	HTTPStatus$1[HTTPStatus$1["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
-	HTTPStatus$1[HTTPStatus$1["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
-	HTTPStatus$1[HTTPStatus$1["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
-	HTTPStatus$1[HTTPStatus$1["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
-	HTTPStatus$1[HTTPStatus$1["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
-	HTTPStatus$1[HTTPStatus$1["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
-	HTTPStatus$1[HTTPStatus$1["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
-	HTTPStatus$1[HTTPStatus$1["LOCKED"] = 423] = "LOCKED";
-	HTTPStatus$1[HTTPStatus$1["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
-	HTTPStatus$1[HTTPStatus$1["TOO_EARLY"] = 425] = "TOO_EARLY";
-	HTTPStatus$1[HTTPStatus$1["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
-	HTTPStatus$1[HTTPStatus$1["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
-	HTTPStatus$1[HTTPStatus$1["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
-	HTTPStatus$1[HTTPStatus$1["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
-	HTTPStatus$1[HTTPStatus$1["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
-	HTTPStatus$1[HTTPStatus$1["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
-	HTTPStatus$1[HTTPStatus$1["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
-	HTTPStatus$1[HTTPStatus$1["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
-	HTTPStatus$1[HTTPStatus$1["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
-	HTTPStatus$1[HTTPStatus$1["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
-	HTTPStatus$1[HTTPStatus$1["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
-	HTTPStatus$1[HTTPStatus$1["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
-	HTTPStatus$1[HTTPStatus$1["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
-	HTTPStatus$1[HTTPStatus$1["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
-	HTTPStatus$1[HTTPStatus$1["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
-	HTTPStatus$1[HTTPStatus$1["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
-	return HTTPStatus$1;
-}({});
-
-//#endregion
-exports.App = App
-exports.BadRequestError = BadRequestError
-exports.BaseMiddleware = BaseMiddleware
-exports.BasePlugin = BasePlugin
-exports.Body = Body
-exports.Connect = Connect
-exports.Controller = Controller
-exports.Delete = Delete
-exports.ErrorHandlerProvider = ErrorHandlerProvider
-exports.ForbiddenError = ForbiddenError
-exports.Get = Get
-exports.GlobalMiddlewareRegistry = GlobalMiddlewareRegistry
-exports.HTTPStatus = HTTPStatus
-exports.Head = Head
-exports.Header = Header
-exports.Headers = Headers$1
-exports.HooksService = HooksService
-exports.HttpError = HttpError
-exports.HttpServer = HttpServer
-exports.InternalServerError = InternalServerError
-exports.Listen = Listen
-exports.MetadataResolver = MetadataResolver
-exports.MethodNotAllowedError = MethodNotAllowedError
-exports.Middleware = Middleware
-exports.MultipartFormData = MultipartFormData
-exports.NotAcceptableError = NotAcceptableError
-exports.NotFoundError = NotFoundError
-exports.Options = Options
-exports.Param = Param
-exports.Patch = Patch
-exports.Post = Post
-exports.Put = Put
-exports.QueryParam = QueryParam
-exports.QueryParams = QueryParams
-exports.Redirect = Redirect
-exports.Request = Request
-exports.Response = Response$1
-exports.Session = Session
-exports.SetHeader = SetHeader
-exports.Status = Status
-exports.Trace = Trace
-exports.UnauthorizedError = UnauthorizedError
-exports.createApp = createApp
-exports.createMetadataCtx = createMetadataCtx
-exports.createMetadataMethod = createMetadataMethod
-exports.defineConfig = defineConfig
-exports.initializeMetadata = initializeMetadata
-exports.initializeMetadataMethod = initializeMetadataMethod
-exports.loadVercubeConfig = loadVercubeConfig